2 * fs/cifs/cifsencrypt.c
4 * Copyright (C) International Business Machines Corp., 2005,2006
5 * Author(s): Steve French (sfrench@us.ibm.com)
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.
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.
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
23 #include <linux/slab.h>
26 #include "cifs_debug.h"
28 #include "cifs_unicode.h"
29 #include "cifsproto.h"
31 #include <linux/ctype.h>
32 #include <linux/random.h>
34 /* Calculate and return the CIFS signature based on the mac key and SMB PDU */
35 /* the 16 byte signature must be allocated by the caller */
36 /* Note we only use the 1st eight bytes */
37 /* Note that the smb header signature field on input contains the
38 sequence number before this function is called */
40 extern void mdfour(unsigned char *out
, unsigned char *in
, int n
);
41 extern void E_md4hash(const unsigned char *passwd
, unsigned char *p16
);
42 extern void SMBencrypt(unsigned char *passwd
, const unsigned char *c8
,
45 static int cifs_calculate_signature(const struct smb_hdr
*cifs_pdu
,
46 const struct session_key
*key
, char *signature
)
48 struct MD5Context context
;
50 if ((cifs_pdu
== NULL
) || (signature
== NULL
) || (key
== NULL
))
53 cifs_MD5_init(&context
);
54 cifs_MD5_update(&context
, (char *)&key
->data
, key
->len
);
55 cifs_MD5_update(&context
, cifs_pdu
->Protocol
, cifs_pdu
->smb_buf_length
);
57 cifs_MD5_final(signature
, &context
);
61 int cifs_sign_smb(struct smb_hdr
*cifs_pdu
, struct TCP_Server_Info
*server
,
62 __u32
*pexpected_response_sequence_number
)
65 char smb_signature
[20];
67 if ((cifs_pdu
== NULL
) || (server
== NULL
))
70 if ((cifs_pdu
->Flags2
& SMBFLG2_SECURITY_SIGNATURE
) == 0)
73 spin_lock(&GlobalMid_Lock
);
74 cifs_pdu
->Signature
.Sequence
.SequenceNumber
=
75 cpu_to_le32(server
->sequence_number
);
76 cifs_pdu
->Signature
.Sequence
.Reserved
= 0;
78 *pexpected_response_sequence_number
= server
->sequence_number
++;
79 server
->sequence_number
++;
80 spin_unlock(&GlobalMid_Lock
);
82 rc
= cifs_calculate_signature(cifs_pdu
, &server
->session_key
,
85 memset(cifs_pdu
->Signature
.SecuritySignature
, 0, 8);
87 memcpy(cifs_pdu
->Signature
.SecuritySignature
, smb_signature
, 8);
92 static int cifs_calc_signature2(const struct kvec
*iov
, int n_vec
,
93 const struct session_key
*key
, char *signature
)
95 struct MD5Context context
;
98 if ((iov
== NULL
) || (signature
== NULL
) || (key
== NULL
))
101 cifs_MD5_init(&context
);
102 cifs_MD5_update(&context
, (char *)&key
->data
, key
->len
);
103 for (i
= 0; i
< n_vec
; i
++) {
104 if (iov
[i
].iov_len
== 0)
106 if (iov
[i
].iov_base
== NULL
) {
107 cERROR(1, "null iovec entry");
110 /* The first entry includes a length field (which does not get
111 signed that occupies the first 4 bytes before the header */
113 if (iov
[0].iov_len
<= 8) /* cmd field at offset 9 */
114 break; /* nothing to sign or corrupt header */
115 cifs_MD5_update(&context
, iov
[0].iov_base
+4,
118 cifs_MD5_update(&context
, iov
[i
].iov_base
, iov
[i
].iov_len
);
121 cifs_MD5_final(signature
, &context
);
127 int cifs_sign_smb2(struct kvec
*iov
, int n_vec
, struct TCP_Server_Info
*server
,
128 __u32
*pexpected_response_sequence_number
)
131 char smb_signature
[20];
132 struct smb_hdr
*cifs_pdu
= iov
[0].iov_base
;
134 if ((cifs_pdu
== NULL
) || (server
== NULL
))
137 if ((cifs_pdu
->Flags2
& SMBFLG2_SECURITY_SIGNATURE
) == 0)
140 spin_lock(&GlobalMid_Lock
);
141 cifs_pdu
->Signature
.Sequence
.SequenceNumber
=
142 cpu_to_le32(server
->sequence_number
);
143 cifs_pdu
->Signature
.Sequence
.Reserved
= 0;
145 *pexpected_response_sequence_number
= server
->sequence_number
++;
146 server
->sequence_number
++;
147 spin_unlock(&GlobalMid_Lock
);
149 rc
= cifs_calc_signature2(iov
, n_vec
, &server
->session_key
,
152 memset(cifs_pdu
->Signature
.SecuritySignature
, 0, 8);
154 memcpy(cifs_pdu
->Signature
.SecuritySignature
, smb_signature
, 8);
159 int cifs_verify_signature(struct smb_hdr
*cifs_pdu
,
160 const struct session_key
*session_key
,
161 __u32 expected_sequence_number
)
164 char server_response_sig
[8];
165 char what_we_think_sig_should_be
[20];
167 if (cifs_pdu
== NULL
|| session_key
== NULL
)
170 if (cifs_pdu
->Command
== SMB_COM_NEGOTIATE
)
173 if (cifs_pdu
->Command
== SMB_COM_LOCKING_ANDX
) {
174 struct smb_com_lock_req
*pSMB
=
175 (struct smb_com_lock_req
*)cifs_pdu
;
176 if (pSMB
->LockType
& LOCKING_ANDX_OPLOCK_RELEASE
)
180 /* BB what if signatures are supposed to be on for session but
181 server does not send one? BB */
183 /* Do not need to verify session setups with signature "BSRSPYL " */
184 if (memcmp(cifs_pdu
->Signature
.SecuritySignature
, "BSRSPYL ", 8) == 0)
185 cFYI(1, "dummy signature received for smb command 0x%x",
188 /* save off the origiginal signature so we can modify the smb and check
189 its signature against what the server sent */
190 memcpy(server_response_sig
, cifs_pdu
->Signature
.SecuritySignature
, 8);
192 cifs_pdu
->Signature
.Sequence
.SequenceNumber
=
193 cpu_to_le32(expected_sequence_number
);
194 cifs_pdu
->Signature
.Sequence
.Reserved
= 0;
196 rc
= cifs_calculate_signature(cifs_pdu
, session_key
,
197 what_we_think_sig_should_be
);
202 /* cifs_dump_mem("what we think it should be: ",
203 what_we_think_sig_should_be, 16); */
205 if (memcmp(server_response_sig
, what_we_think_sig_should_be
, 8))
212 /* We fill in key by putting in 40 byte array which was allocated by caller */
213 int cifs_calculate_session_key(struct session_key
*key
, const char *rn
,
214 const char *password
)
217 if ((key
== NULL
) || (rn
== NULL
))
220 E_md4hash(password
, temp_key
);
221 mdfour(key
->data
.ntlm
, temp_key
, 16);
222 memcpy(key
->data
.ntlm
+16, rn
, CIFS_SESS_KEY_SIZE
);
227 #ifdef CONFIG_CIFS_WEAK_PW_HASH
228 void calc_lanman_hash(const char *password
, const char *cryptkey
, bool encrypt
,
229 char *lnm_session_key
)
232 char password_with_pad
[CIFS_ENCPWD_SIZE
];
234 memset(password_with_pad
, 0, CIFS_ENCPWD_SIZE
);
236 strncpy(password_with_pad
, password
, CIFS_ENCPWD_SIZE
);
238 if (!encrypt
&& global_secflags
& CIFSSEC_MAY_PLNTXT
) {
239 memset(lnm_session_key
, 0, CIFS_SESS_KEY_SIZE
);
240 memcpy(lnm_session_key
, password_with_pad
,
245 /* calculate old style session key */
246 /* calling toupper is less broken than repeatedly
247 calling nls_toupper would be since that will never
248 work for UTF8, but neither handles multibyte code pages
249 but the only alternative would be converting to UCS-16 (Unicode)
250 (using a routine something like UniStrupr) then
251 uppercasing and then converting back from Unicode - which
252 would only worth doing it if we knew it were utf8. Basically
253 utf8 and other multibyte codepages each need their own strupper
254 function since a byte at a time will ont work. */
256 for (i
= 0; i
< CIFS_ENCPWD_SIZE
; i
++)
257 password_with_pad
[i
] = toupper(password_with_pad
[i
]);
259 SMBencrypt(password_with_pad
, cryptkey
, lnm_session_key
);
261 /* clear password before we return/free memory */
262 memset(password_with_pad
, 0, CIFS_ENCPWD_SIZE
);
264 #endif /* CIFS_WEAK_PW_HASH */
266 /* Build a proper attribute value/target info pairs blob.
267 * Fill in netbios and dns domain name and workstation name
268 * and client time (total five av pairs and + one end of fields indicator.
269 * Allocate domain name which gets freed when session struct is deallocated.
272 build_avpair_blob(struct cifsSesInfo
*ses
, const struct nls_table
*nls_cp
)
276 unsigned int size
= 6 * sizeof(struct ntlmssp2_name
);
278 char *defdmname
= "WORKGROUP";
279 unsigned char *blobptr
;
280 struct ntlmssp2_name
*attrptr
;
282 if (!ses
->domainName
) {
283 ses
->domainName
= kstrdup(defdmname
, GFP_KERNEL
);
284 if (!ses
->domainName
)
288 dlen
= strlen(ses
->domainName
);
289 wlen
= strlen(ses
->server
->hostname
);
291 /* The length of this blob is a size which is
292 * six times the size of a structure which holds name/size +
293 * two times the unicode length of a domain name +
294 * two times the unicode length of a server name +
295 * size of a timestamp (which is 8 bytes).
297 ses
->tilen
= size
+ 2 * (2 * dlen
) + 2 * (2 * wlen
) + 8;
298 ses
->tiblob
= kzalloc(ses
->tilen
, GFP_KERNEL
);
301 cERROR(1, "Challenge target info allocation failure");
305 blobptr
= ses
->tiblob
;
306 attrptr
= (struct ntlmssp2_name
*) blobptr
;
308 attrptr
->type
= cpu_to_le16(NTLMSSP_AV_NB_DOMAIN_NAME
);
309 attrptr
->length
= cpu_to_le16(2 * dlen
);
310 blobptr
= (unsigned char *)attrptr
+ sizeof(struct ntlmssp2_name
);
311 cifs_strtoUCS((__le16
*)blobptr
, ses
->domainName
, dlen
, nls_cp
);
314 attrptr
= (struct ntlmssp2_name
*) blobptr
;
316 attrptr
->type
= cpu_to_le16(NTLMSSP_AV_NB_COMPUTER_NAME
);
317 attrptr
->length
= cpu_to_le16(2 * wlen
);
318 blobptr
= (unsigned char *)attrptr
+ sizeof(struct ntlmssp2_name
);
319 cifs_strtoUCS((__le16
*)blobptr
, ses
->server
->hostname
, wlen
, nls_cp
);
322 attrptr
= (struct ntlmssp2_name
*) blobptr
;
324 attrptr
->type
= cpu_to_le16(NTLMSSP_AV_DNS_DOMAIN_NAME
);
325 attrptr
->length
= cpu_to_le16(2 * dlen
);
326 blobptr
= (unsigned char *)attrptr
+ sizeof(struct ntlmssp2_name
);
327 cifs_strtoUCS((__le16
*)blobptr
, ses
->domainName
, dlen
, nls_cp
);
330 attrptr
= (struct ntlmssp2_name
*) blobptr
;
332 attrptr
->type
= cpu_to_le16(NTLMSSP_AV_DNS_COMPUTER_NAME
);
333 attrptr
->length
= cpu_to_le16(2 * wlen
);
334 blobptr
= (unsigned char *)attrptr
+ sizeof(struct ntlmssp2_name
);
335 cifs_strtoUCS((__le16
*)blobptr
, ses
->server
->hostname
, wlen
, nls_cp
);
338 attrptr
= (struct ntlmssp2_name
*) blobptr
;
340 attrptr
->type
= cpu_to_le16(NTLMSSP_AV_TIMESTAMP
);
341 attrptr
->length
= cpu_to_le16(sizeof(__le64
));
342 blobptr
= (unsigned char *)attrptr
+ sizeof(struct ntlmssp2_name
);
343 curtime
= cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME
));
344 memcpy(blobptr
, &curtime
, sizeof(__le64
));
349 /* Server has provided av pairs/target info in the type 2 challenge
350 * packet and we have plucked it and stored within smb session.
351 * We parse that blob here to find netbios domain name to be used
352 * as part of ntlmv2 authentication (in Target String), if not already
353 * specified on the command line.
354 * If this function returns without any error but without fetching
355 * domain name, authentication may fail against some server but
356 * may not fail against other (those who are not very particular
357 * about target string i.e. for some, just user name might suffice.
360 find_domain_name(struct cifsSesInfo
*ses
)
362 unsigned int attrsize
;
364 unsigned int onesize
= sizeof(struct ntlmssp2_name
);
365 unsigned char *blobptr
;
366 unsigned char *blobend
;
367 struct ntlmssp2_name
*attrptr
;
369 if (!ses
->tilen
|| !ses
->tiblob
)
372 blobptr
= ses
->tiblob
;
373 blobend
= ses
->tiblob
+ ses
->tilen
;
375 while (blobptr
+ onesize
< blobend
) {
376 attrptr
= (struct ntlmssp2_name
*) blobptr
;
377 type
= le16_to_cpu(attrptr
->type
);
378 if (type
== NTLMSSP_AV_EOL
)
380 blobptr
+= 2; /* advance attr type */
381 attrsize
= le16_to_cpu(attrptr
->length
);
382 blobptr
+= 2; /* advance attr size */
383 if (blobptr
+ attrsize
> blobend
)
385 if (type
== NTLMSSP_AV_NB_DOMAIN_NAME
) {
388 if (!ses
->domainName
) {
389 struct nls_table
*default_nls
;
391 kmalloc(attrsize
+ 1, GFP_KERNEL
);
392 if (!ses
->domainName
)
394 default_nls
= load_nls_default();
395 cifs_from_ucs2(ses
->domainName
,
396 (__le16
*)blobptr
, attrsize
, attrsize
,
398 unload_nls(default_nls
);
402 blobptr
+= attrsize
; /* advance attr value */
408 static int calc_ntlmv2_hash(struct cifsSesInfo
*ses
,
409 const struct nls_table
*nls_cp
)
414 struct HMACMD5Context
*pctxt
;
418 pctxt
= kmalloc(sizeof(struct HMACMD5Context
), GFP_KERNEL
);
423 /* calculate md4 hash of password */
424 E_md4hash(ses
->password
, nt_hash
);
426 /* convert Domainname to unicode and uppercase */
427 hmac_md5_init_limK_to_64(nt_hash
, 16, pctxt
);
429 /* convert ses->userName to unicode and uppercase */
430 len
= strlen(ses
->userName
);
431 user
= kmalloc(2 + (len
* 2), GFP_KERNEL
);
434 len
= cifs_strtoUCS((__le16
*)user
, ses
->userName
, len
, nls_cp
);
436 hmac_md5_update((char *)user
, 2*len
, pctxt
);
438 /* convert ses->domainName to unicode and uppercase */
439 if (ses
->domainName
) {
440 len
= strlen(ses
->domainName
);
442 domain
= kmalloc(2 + (len
* 2), GFP_KERNEL
);
445 len
= cifs_strtoUCS((__le16
*)domain
, ses
->domainName
, len
,
447 /* the following line was removed since it didn't work well
448 with lower cased domain name that passed as an option.
449 Maybe converting the domain name earlier makes sense */
450 /* UniStrupr(domain); */
452 hmac_md5_update((char *)domain
, 2*len
, pctxt
);
459 /* BB FIXME what about bytes 24 through 40 of the signing key?
460 compare with the NTLM example */
461 hmac_md5_final(ses
->ntlmv2_hash
, pctxt
);
468 setup_ntlmv2_rsp(struct cifsSesInfo
*ses
, char *resp_buf
,
469 const struct nls_table
*nls_cp
)
472 struct ntlmv2_resp
*buf
= (struct ntlmv2_resp
*)resp_buf
;
473 struct HMACMD5Context context
;
475 buf
->blob_signature
= cpu_to_le32(0x00000101);
477 buf
->time
= cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME
));
478 get_random_bytes(&buf
->client_chal
, sizeof(buf
->client_chal
));
481 if (ses
->server
->secType
== RawNTLMSSP
) {
482 if (!ses
->domainName
) {
483 rc
= find_domain_name(ses
);
485 cERROR(1, "error %d finding domain name", rc
);
486 goto setup_ntlmv2_rsp_ret
;
490 rc
= build_avpair_blob(ses
, nls_cp
);
492 cERROR(1, "error %d building av pair blob", rc
);
497 /* calculate buf->ntlmv2_hash */
498 rc
= calc_ntlmv2_hash(ses
, nls_cp
);
500 cERROR(1, "could not get v2 hash rc %d", rc
);
501 goto setup_ntlmv2_rsp_ret
;
503 CalcNTLMv2_response(ses
, resp_buf
);
505 /* now calculate the session key for NTLMv2 */
506 hmac_md5_init_limK_to_64(ses
->ntlmv2_hash
, 16, &context
);
507 hmac_md5_update(resp_buf
, 16, &context
);
508 hmac_md5_final(ses
->auth_key
.data
.ntlmv2
.key
, &context
);
510 memcpy(&ses
->auth_key
.data
.ntlmv2
.resp
, resp_buf
,
511 sizeof(struct ntlmv2_resp
));
512 ses
->auth_key
.len
= 16 + sizeof(struct ntlmv2_resp
);
516 setup_ntlmv2_rsp_ret
:
524 void CalcNTLMv2_response(const struct cifsSesInfo
*ses
,
525 char *v2_session_response
)
527 struct HMACMD5Context context
;
528 /* rest of v2 struct already generated */
529 memcpy(v2_session_response
+ 8, ses
->cryptKey
, 8);
530 hmac_md5_init_limK_to_64(ses
->ntlmv2_hash
, 16, &context
);
532 hmac_md5_update(v2_session_response
+8,
533 sizeof(struct ntlmv2_resp
) - 8, &context
);
536 hmac_md5_update(ses
->tiblob
, ses
->tilen
, &context
);
538 hmac_md5_final(v2_session_response
, &context
);
539 /* cifs_dump_mem("v2_sess_rsp: ", v2_session_response, 32); */