1/* 2 * fs/cifs/cifsencrypt.c 3 * 4 * Copyright (C) International Business Machines Corp., 2005,2006 5 * Author(s): Steve French (sfrench@us.ibm.com) 6 * 7 * This library is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU Lesser General Public License as published 9 * by the Free Software Foundation; either version 2.1 of the License, or 10 * (at your option) any later version. 11 * 12 * This library 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 15 * the GNU Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public License 18 * along with this library; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22#include <linux/fs.h> 23#include "cifspdu.h" 24#include "cifsglob.h" 25#include "cifs_debug.h" 26#include "md5.h" 27#include "cifs_unicode.h" 28#include "cifsproto.h" 29#include <linux/ctype.h> 30#include <linux/random.h> 31 32/* Calculate and return the CIFS signature based on the mac key and the smb pdu */ 33/* the 16 byte signature must be allocated by the caller */ 34/* Note we only use the 1st eight bytes */ 35/* Note that the smb header signature field on input contains the 36 sequence number before this function is called */ 37 38extern void mdfour(unsigned char *out, unsigned char *in, int n); 39extern void E_md4hash(const unsigned char *passwd, unsigned char *p16); 40extern void SMBencrypt(unsigned char *passwd, unsigned char *c8, 41 unsigned char *p24); 42 43static int cifs_calculate_signature(const struct smb_hdr * cifs_pdu, 44 const char * key, char * signature) 45{ 46 struct MD5Context context; 47 48 if((cifs_pdu == NULL) || (signature == NULL)) 49 return -EINVAL; 50 51 MD5Init(&context); 52 MD5Update(&context,key,CIFS_SESS_KEY_SIZE+16); 53 MD5Update(&context,cifs_pdu->Protocol,cifs_pdu->smb_buf_length); 54 MD5Final(signature,&context); 55 return 0; 56} 57 58int cifs_sign_smb(struct smb_hdr * cifs_pdu, struct TCP_Server_Info * server, 59 __u32 * pexpected_response_sequence_number) 60{ 61 int rc = 0; 62 char smb_signature[20]; 63 64 if((cifs_pdu == NULL) || (server == NULL)) 65 return -EINVAL; 66 67 if((cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) == 0) 68 return rc; 69 70 spin_lock(&GlobalMid_Lock); 71 cifs_pdu->Signature.Sequence.SequenceNumber = cpu_to_le32(server->sequence_number); 72 cifs_pdu->Signature.Sequence.Reserved = 0; 73 74 *pexpected_response_sequence_number = server->sequence_number++; 75 server->sequence_number++; 76 spin_unlock(&GlobalMid_Lock); 77 78 rc = cifs_calculate_signature(cifs_pdu, server->mac_signing_key,smb_signature); 79 if(rc) 80 memset(cifs_pdu->Signature.SecuritySignature, 0, 8); 81 else 82 memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8); 83 84 return rc; 85} 86 87static int cifs_calc_signature2(const struct kvec * iov, int n_vec, 88 const char * key, char * signature) 89{ 90 struct MD5Context context; 91 int i; 92 93 if((iov == NULL) || (signature == NULL)) 94 return -EINVAL; 95 96 MD5Init(&context); 97 MD5Update(&context,key,CIFS_SESS_KEY_SIZE+16); 98 for(i=0;i<n_vec;i++) { 99 if(iov[i].iov_base == NULL) { 100 cERROR(1,("null iovec entry")); 101 return -EIO; 102 } else if(iov[i].iov_len == 0) 103 break; /* bail out if we are sent nothing to sign */ 104 /* The first entry includes a length field (which does not get 105 signed that occupies the first 4 bytes before the header */ 106 if(i==0) { 107 if (iov[0].iov_len <= 8 ) /* cmd field at offset 9 */ 108 break; /* nothing to sign or corrupt header */ 109 MD5Update(&context,iov[0].iov_base+4, iov[0].iov_len-4); 110 } else 111 MD5Update(&context,iov[i].iov_base, iov[i].iov_len); 112 } 113 114 MD5Final(signature,&context); 115 116 return 0; 117} 118 119 120int cifs_sign_smb2(struct kvec * iov, int n_vec, struct TCP_Server_Info *server, 121 __u32 * pexpected_response_sequence_number) 122{ 123 int rc = 0; 124 char smb_signature[20]; 125 struct smb_hdr * cifs_pdu = iov[0].iov_base; 126 127 if((cifs_pdu == NULL) || (server == NULL)) 128 return -EINVAL; 129 130 if((cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) == 0) 131 return rc; 132 133 spin_lock(&GlobalMid_Lock); 134 cifs_pdu->Signature.Sequence.SequenceNumber = 135 cpu_to_le32(server->sequence_number); 136 cifs_pdu->Signature.Sequence.Reserved = 0; 137 138 *pexpected_response_sequence_number = server->sequence_number++; 139 server->sequence_number++; 140 spin_unlock(&GlobalMid_Lock); 141 142 rc = cifs_calc_signature2(iov, n_vec, server->mac_signing_key, 143 smb_signature); 144 if(rc) 145 memset(cifs_pdu->Signature.SecuritySignature, 0, 8); 146 else 147 memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8); 148 149 return rc; 150 151} 152 153int cifs_verify_signature(struct smb_hdr * cifs_pdu, const char * mac_key, 154 __u32 expected_sequence_number) 155{ 156 unsigned int rc; 157 char server_response_sig[8]; 158 char what_we_think_sig_should_be[20]; 159 160 if((cifs_pdu == NULL) || (mac_key == NULL)) 161 return -EINVAL; 162 163 if (cifs_pdu->Command == SMB_COM_NEGOTIATE) 164 return 0; 165 166 if (cifs_pdu->Command == SMB_COM_LOCKING_ANDX) { 167 struct smb_com_lock_req * pSMB = (struct smb_com_lock_req *)cifs_pdu; 168 if(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE) 169 return 0; 170 } 171 172 /* BB what if signatures are supposed to be on for session but server does not 173 send one? BB */ 174 175 /* Do not need to verify session setups with signature "BSRSPYL " */ 176 if(memcmp(cifs_pdu->Signature.SecuritySignature,"BSRSPYL ",8)==0) 177 cFYI(1,("dummy signature received for smb command 0x%x",cifs_pdu->Command)); 178 179 /* save off the origiginal signature so we can modify the smb and check 180 its signature against what the server sent */ 181 memcpy(server_response_sig,cifs_pdu->Signature.SecuritySignature,8); 182 183 cifs_pdu->Signature.Sequence.SequenceNumber = cpu_to_le32(expected_sequence_number); 184 cifs_pdu->Signature.Sequence.Reserved = 0; 185 186 rc = cifs_calculate_signature(cifs_pdu, mac_key, 187 what_we_think_sig_should_be); 188 189 if(rc) 190 return rc; 191 192 193/* cifs_dump_mem("what we think it should be: ",what_we_think_sig_should_be,16); */ 194 195 if(memcmp(server_response_sig, what_we_think_sig_should_be, 8)) 196 return -EACCES; 197 else 198 return 0; 199 200} 201 202/* We fill in key by putting in 40 byte array which was allocated by caller */ 203int cifs_calculate_mac_key(char * key, const char * rn, const char * password) 204{ 205 char temp_key[16]; 206 if ((key == NULL) || (rn == NULL)) 207 return -EINVAL; 208 209 E_md4hash(password, temp_key); 210 mdfour(key,temp_key,16); 211 memcpy(key+16,rn, CIFS_SESS_KEY_SIZE); 212 return 0; 213} 214 215int CalcNTLMv2_partial_mac_key(struct cifsSesInfo * ses, 216 const struct nls_table * nls_info) 217{ 218 char temp_hash[16]; 219 struct HMACMD5Context ctx; 220 char * ucase_buf; 221 __le16 * unicode_buf; 222 unsigned int i,user_name_len,dom_name_len; 223 224 if(ses == NULL) 225 return -EINVAL; 226 227 E_md4hash(ses->password, temp_hash); 228 229 hmac_md5_init_limK_to_64(temp_hash, 16, &ctx); 230 user_name_len = strlen(ses->userName); 231 if(user_name_len > MAX_USERNAME_SIZE) 232 return -EINVAL; 233 if(ses->domainName == NULL) 234 return -EINVAL; /* BB should we use CIFS_LINUX_DOM */ 235 dom_name_len = strlen(ses->domainName); 236 if(dom_name_len > MAX_USERNAME_SIZE) 237 return -EINVAL; 238 239 ucase_buf = kmalloc((MAX_USERNAME_SIZE+1), GFP_KERNEL); 240 if(ucase_buf == NULL) 241 return -ENOMEM; 242 unicode_buf = kmalloc((MAX_USERNAME_SIZE+1)*4, GFP_KERNEL); 243 if(unicode_buf == NULL) { 244 kfree(ucase_buf); 245 return -ENOMEM; 246 } 247 248 for(i=0;i<user_name_len;i++) 249 ucase_buf[i] = nls_info->charset2upper[(int)ses->userName[i]]; 250 ucase_buf[i] = 0; 251 user_name_len = cifs_strtoUCS(unicode_buf, ucase_buf, MAX_USERNAME_SIZE*2, nls_info); 252 unicode_buf[user_name_len] = 0; 253 user_name_len++; 254 255 for(i=0;i<dom_name_len;i++) 256 ucase_buf[i] = nls_info->charset2upper[(int)ses->domainName[i]]; 257 ucase_buf[i] = 0; 258 dom_name_len = cifs_strtoUCS(unicode_buf+user_name_len, ucase_buf, MAX_USERNAME_SIZE*2, nls_info); 259 260 unicode_buf[user_name_len + dom_name_len] = 0; 261 hmac_md5_update((const unsigned char *) unicode_buf, 262 (user_name_len+dom_name_len)*2,&ctx); 263 264 hmac_md5_final(ses->server->mac_signing_key,&ctx); 265 kfree(ucase_buf); 266 kfree(unicode_buf); 267 return 0; 268} 269 270#ifdef CONFIG_CIFS_WEAK_PW_HASH 271void calc_lanman_hash(struct cifsSesInfo * ses, char * lnm_session_key) 272{ 273 int i; 274 char password_with_pad[CIFS_ENCPWD_SIZE]; 275 276 if(ses->server == NULL) 277 return; 278 279 memset(password_with_pad, 0, CIFS_ENCPWD_SIZE); 280 if(ses->password) 281 strncpy(password_with_pad, ses->password, CIFS_ENCPWD_SIZE); 282 283 if((ses->server->secMode & SECMODE_PW_ENCRYPT) == 0) 284 if(extended_security & CIFSSEC_MAY_PLNTXT) { 285 memcpy(lnm_session_key, password_with_pad, CIFS_ENCPWD_SIZE); 286 return; 287 } 288 289 /* calculate old style session key */ 290 /* calling toupper is less broken than repeatedly 291 calling nls_toupper would be since that will never 292 work for UTF8, but neither handles multibyte code pages 293 but the only alternative would be converting to UCS-16 (Unicode) 294 (using a routine something like UniStrupr) then 295 uppercasing and then converting back from Unicode - which 296 would only worth doing it if we knew it were utf8. Basically 297 utf8 and other multibyte codepages each need their own strupper 298 function since a byte at a time will ont work. */ 299 300 for(i = 0; i < CIFS_ENCPWD_SIZE; i++) { 301 password_with_pad[i] = toupper(password_with_pad[i]); 302 } 303 304 SMBencrypt(password_with_pad, ses->server->cryptKey, lnm_session_key); 305 /* clear password before we return/free memory */ 306 memset(password_with_pad, 0, CIFS_ENCPWD_SIZE); 307} 308#endif /* CIFS_WEAK_PW_HASH */ 309 310static int calc_ntlmv2_hash(struct cifsSesInfo *ses, 311 const struct nls_table * nls_cp) 312{ 313 int rc = 0; 314 int len; 315 char nt_hash[16]; 316 struct HMACMD5Context * pctxt; 317 wchar_t * user; 318 wchar_t * domain; 319 320 pctxt = kmalloc(sizeof(struct HMACMD5Context), GFP_KERNEL); 321 322 if(pctxt == NULL) 323 return -ENOMEM; 324 325 /* calculate md4 hash of password */ 326 E_md4hash(ses->password, nt_hash); 327 328 /* convert Domainname to unicode and uppercase */ 329 hmac_md5_init_limK_to_64(nt_hash, 16, pctxt); 330 331 /* convert ses->userName to unicode and uppercase */ 332 len = strlen(ses->userName); 333 user = kmalloc(2 + (len * 2), GFP_KERNEL); 334 if(user == NULL) 335 goto calc_exit_2; 336 len = cifs_strtoUCS(user, ses->userName, len, nls_cp); 337 UniStrupr(user); 338 hmac_md5_update((char *)user, 2*len, pctxt); 339 340 /* convert ses->domainName to unicode and uppercase */ 341 if(ses->domainName) { 342 len = strlen(ses->domainName); 343 344 domain = kmalloc(2 + (len * 2), GFP_KERNEL); 345 if(domain == NULL) 346 goto calc_exit_1; 347 len = cifs_strtoUCS(domain, ses->domainName, len, nls_cp); 348 UniStrupr(domain); 349 350 hmac_md5_update((char *)domain, 2*len, pctxt); 351 352 kfree(domain); 353 } 354calc_exit_1: 355 kfree(user); 356calc_exit_2: 357 hmac_md5_final(ses->server->mac_signing_key, pctxt); 358 359 return rc; 360} 361 362void setup_ntlmv2_rsp(struct cifsSesInfo * ses, char * resp_buf, 363 const struct nls_table * nls_cp) 364{ 365 int rc; 366 struct ntlmv2_resp * buf = (struct ntlmv2_resp *)resp_buf; 367 368 buf->blob_signature = cpu_to_le32(0x00000101); 369 buf->reserved = 0; 370 buf->time = cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME)); 371 get_random_bytes(&buf->client_chal, sizeof(buf->client_chal)); 372 buf->reserved2 = 0; 373 buf->names[0].type = cpu_to_le16(NTLMSSP_DOMAIN_TYPE); 374 buf->names[0].length = 0; 375 buf->names[1].type = 0; 376 buf->names[1].length = 0; 377 378 /* calculate buf->ntlmv2_hash */ 379 rc = calc_ntlmv2_hash(ses, nls_cp); 380 if(rc) 381 cERROR(1,("could not get v2 hash rc %d",rc)); 382 CalcNTLMv2_response(ses, resp_buf); 383} 384 385void CalcNTLMv2_response(const struct cifsSesInfo * ses, char * v2_session_response) 386{ 387 struct HMACMD5Context context; 388 /* rest of v2 struct already generated */ 389 memcpy(v2_session_response + 8, ses->server->cryptKey,8); 390 hmac_md5_init_limK_to_64(ses->server->mac_signing_key, 16, &context); 391 392 hmac_md5_update(v2_session_response+8, 393 sizeof(struct ntlmv2_resp) - 8, &context); 394 395 hmac_md5_final(v2_session_response,&context); 396/* cifs_dump_mem("v2_sess_rsp: ", v2_session_response, 32); */ 397} 398