release/src/router/samba/source/libsmb/pwd_cache.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Password cacheing.  obfuscation is planned
   5    Copyright (C) Luke Kenneth Casson Leighton 1996-1998
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 extern int DEBUGLEVEL;
  25
  26
  27 /****************************************************************************
  28 initialises a password structure
  29 ****************************************************************************/
  30 void pwd_init(struct pwd_info *pwd)
  31 {
  32         memset((char *)pwd->password  , '\0', sizeof(pwd->password  ));
  33         memset((char *)pwd->smb_lm_pwd, '\0', sizeof(pwd->smb_lm_pwd));
  34         memset((char *)pwd->smb_nt_pwd, '\0', sizeof(pwd->smb_nt_pwd));
  35         memset((char *)pwd->smb_lm_owf, '\0', sizeof(pwd->smb_lm_owf));
  36         memset((char *)pwd->smb_nt_owf, '\0', sizeof(pwd->smb_nt_owf));
  37
  38         pwd->null_pwd  = True; /* safest option... */
  39         pwd->cleartext = False;
  40         pwd->crypted   = False;
  41 }
  42
  43 /****************************************************************************
  44 de-obfuscates a password
  45 ****************************************************************************/
  46 static void pwd_deobfuscate(struct pwd_info *pwd)
  47 {
  48 }
  49
  50 /****************************************************************************
  51 obfuscates a password
  52 ****************************************************************************/
  53 static void pwd_obfuscate(struct pwd_info *pwd)
  54 {
  55 }
  56
  57 /****************************************************************************
  58 sets the obfuscation key info
  59 ****************************************************************************/
  60 void pwd_obfuscate_key(struct pwd_info *pwd, uint32 int_key, char *str_key)
  61 {
  62 }
  63
  64 /****************************************************************************
  65 reads a password
  66 ****************************************************************************/
  67 void pwd_read(struct pwd_info *pwd, char *passwd_report, BOOL do_encrypt)
  68 {
  69         /* grab a password */
  70         char *user_pass;
  71
  72         pwd_init(pwd);
  73
  74         user_pass = (char*)getpass(passwd_report);
  75
  76         if (user_pass == NULL || user_pass[0] == 0)
  77         {
  78                 pwd_set_nullpwd(pwd);
  79         }
  80         else if (do_encrypt)
  81         {
  82                 pwd_make_lm_nt_16(pwd, user_pass);
  83         }
  84         else
  85         {
  86                 pwd_set_cleartext(pwd, user_pass);
  87         }
  88 }
  89
  90 /****************************************************************************
  91  stores a cleartext password
  92  ****************************************************************************/
  93 void pwd_set_nullpwd(struct pwd_info *pwd)
  94 {
  95         pwd_init(pwd);
  96
  97         pwd->cleartext = False;
  98         pwd->null_pwd  = True;
  99         pwd->crypted   = False;
 100 }
 101
 102 /****************************************************************************
 103  stores a cleartext password
 104  ****************************************************************************/
 105 void pwd_set_cleartext(struct pwd_info *pwd, char *clr)
 106 {
 107         pwd_init(pwd);
 108         fstrcpy(pwd->password, clr);
 109         unix_to_dos(pwd->password,True);
 110         pwd->cleartext = True;
 111         pwd->null_pwd  = False;
 112         pwd->crypted   = False;
 113
 114         pwd_obfuscate(pwd);
 115 }
 116
 117 /****************************************************************************
 118  gets a cleartext password
 119  ****************************************************************************/
 120 void pwd_get_cleartext(struct pwd_info *pwd, char *clr)
 121 {
 122         pwd_deobfuscate(pwd);
 123         if (pwd->cleartext)
 124         {
 125                 fstrcpy(clr, pwd->password);
 126                 dos_to_unix(clr, True);
 127         }
 128         else
 129         {
 130                 clr[0] = 0;
 131         }
 132         pwd_obfuscate(pwd);
 133 }
 134
 135 /****************************************************************************
 136  stores lm and nt hashed passwords
 137  ****************************************************************************/
 138 void pwd_set_lm_nt_16(struct pwd_info *pwd, uchar lm_pwd[16], uchar nt_pwd[16])
 139 {
 140         pwd_init(pwd);
 141
 142         if (lm_pwd)
 143         {
 144                 memcpy(pwd->smb_lm_pwd, lm_pwd, 16);
 145         }
 146         else
 147         {
 148                 memset((char *)pwd->smb_lm_pwd, '\0', 16);
 149         }
 150
 151         if (nt_pwd)
 152         {
 153                 memcpy(pwd->smb_nt_pwd, nt_pwd, 16);
 154         }
 155         else
 156         {
 157                 memset((char *)pwd->smb_nt_pwd, '\0', 16);
 158         }
 159
 160         pwd->null_pwd  = False;
 161         pwd->cleartext = False;
 162         pwd->crypted   = False;
 163
 164         pwd_obfuscate(pwd);
 165 }
 166
 167 /****************************************************************************
 168  gets lm and nt hashed passwords
 169  ****************************************************************************/
 170 void pwd_get_lm_nt_16(struct pwd_info *pwd, uchar lm_pwd[16], uchar nt_pwd[16])
 171 {
 172         pwd_deobfuscate(pwd);
 173         if (lm_pwd != NULL)
 174         {
 175                 memcpy(lm_pwd, pwd->smb_lm_pwd, 16);
 176         }
 177         if (nt_pwd != NULL)
 178         {
 179                 memcpy(nt_pwd, pwd->smb_nt_pwd, 16);
 180         }
 181         pwd_obfuscate(pwd);
 182 }
 183
 184 /****************************************************************************
 185  makes lm and nt hashed passwords
 186  ****************************************************************************/
 187 void pwd_make_lm_nt_16(struct pwd_info *pwd, char *clr)
 188 {
 189         pstring dos_passwd;
 190
 191         pwd_init(pwd);
 192
 193         pstrcpy(dos_passwd, clr);
 194         unix_to_dos(dos_passwd, True);
 195
 196         nt_lm_owf_gen(dos_passwd, pwd->smb_nt_pwd, pwd->smb_lm_pwd);
 197         pwd->null_pwd  = False;
 198         pwd->cleartext = False;
 199         pwd->crypted = False;
 200
 201         pwd_obfuscate(pwd);
 202 }
 203
 204 /****************************************************************************
 205  makes lm and nt OWF crypts
 206  ****************************************************************************/
 207 void pwd_make_lm_nt_owf(struct pwd_info *pwd, uchar cryptkey[8])
 208 {
 209         pwd_deobfuscate(pwd);
 210
 211 #ifdef DEBUG_PASSWORD
 212         DEBUG(100,("client cryptkey: "));
 213         dump_data(100, (char *)cryptkey, 8);
 214 #endif
 215
 216         SMBOWFencrypt(pwd->smb_nt_pwd, cryptkey, pwd->smb_nt_owf);
 217
 218 #ifdef DEBUG_PASSWORD
 219         DEBUG(100,("nt_owf_passwd: "));
 220         dump_data(100, (char *)pwd->smb_nt_owf, sizeof(pwd->smb_nt_owf));
 221         DEBUG(100,("nt_sess_pwd: "));
 222         dump_data(100, (char *)pwd->smb_nt_pwd, sizeof(pwd->smb_nt_pwd));
 223 #endif
 224
 225         SMBOWFencrypt(pwd->smb_lm_pwd, cryptkey, pwd->smb_lm_owf);
 226
 227 #ifdef DEBUG_PASSWORD
 228         DEBUG(100,("lm_owf_passwd: "));
 229         dump_data(100, (char *)pwd->smb_lm_owf, sizeof(pwd->smb_lm_owf));
 230         DEBUG(100,("lm_sess_pwd: "));
 231         dump_data(100, (char *)pwd->smb_lm_pwd, sizeof(pwd->smb_lm_pwd));
 232 #endif
 233
 234         pwd->crypted = True;
 235
 236         pwd_obfuscate(pwd);
 237 }
 238
 239 /****************************************************************************
 240  gets lm and nt crypts
 241  ****************************************************************************/
 242 void pwd_get_lm_nt_owf(struct pwd_info *pwd, uchar lm_owf[24], uchar nt_owf[24])
 243 {
 244         pwd_deobfuscate(pwd);
 245         if (lm_owf != NULL)
 246         {
 247                 memcpy(lm_owf, pwd->smb_lm_owf, 24);
 248         }
 249         if (nt_owf != NULL)
 250         {
 251                 memcpy(nt_owf, pwd->smb_nt_owf, 24);
 252         }
 253         pwd_obfuscate(pwd);
 254 }