src/vfs/smbfs/helpers/libsmb/pwd_cache.c

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