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 /* This is just a filler for ntlmv2 type of security mechanisms.
267 * Older servers are not very particular about the contents of av pairs
268 * in the blob and for sec mechs like ntlmv2, there is no negotiation
269 * as in ntlmssp, so unless domain and server netbios and dns names
270 * are specified, there is no way to obtain name. In case of ntlmssp,
271 * server provides that info in type 2 challenge packet
274 build_avpair_blob(struct cifsSesInfo
*ses
)
276 struct ntlmssp2_name
*attrptr
;
278 ses
->tilen
= 2 * sizeof(struct ntlmssp2_name
);
279 ses
->tiblob
= kzalloc(ses
->tilen
, GFP_KERNEL
);
282 cERROR(1, "Challenge target info allocation failure");
285 attrptr
= (struct ntlmssp2_name
*) ses
->tiblob
;
286 attrptr
->type
= cpu_to_le16(NTLMSSP_DOMAIN_TYPE
);
291 /* Server has provided av pairs/target info in the type 2 challenge
292 * packet and we have plucked it and stored within smb session.
293 * We parse that blob here to find netbios domain name to be used
294 * as part of ntlmv2 authentication (in Target String), if not already
295 * specified on the command line.
296 * If this function returns without any error but without fetching
297 * domain name, authentication may fail against some server but
298 * may not fail against other (those who are not very particular
299 * about target string i.e. for some, just user name might suffice.
302 find_domain_name(struct cifsSesInfo
*ses
)
304 unsigned int attrsize
;
306 unsigned int onesize
= sizeof(struct ntlmssp2_name
);
307 unsigned char *blobptr
;
308 unsigned char *blobend
;
309 struct ntlmssp2_name
*attrptr
;
311 if (!ses
->tilen
|| !ses
->tiblob
)
314 blobptr
= ses
->tiblob
;
315 blobend
= ses
->tiblob
+ ses
->tilen
;
317 while (blobptr
+ onesize
< blobend
) {
318 attrptr
= (struct ntlmssp2_name
*) blobptr
;
319 type
= le16_to_cpu(attrptr
->type
);
320 if (type
== NTLMSSP_AV_EOL
)
322 blobptr
+= 2; /* advance attr type */
323 attrsize
= le16_to_cpu(attrptr
->length
);
324 blobptr
+= 2; /* advance attr size */
325 if (blobptr
+ attrsize
> blobend
)
327 if (type
== NTLMSSP_AV_NB_DOMAIN_NAME
) {
330 if (!ses
->domainName
) {
332 kmalloc(attrsize
+ 1, GFP_KERNEL
);
333 if (!ses
->domainName
)
335 cifs_from_ucs2(ses
->domainName
,
336 (__le16
*)blobptr
, attrsize
, attrsize
,
337 load_nls_default(), false);
341 blobptr
+= attrsize
; /* advance attr value */
347 static int calc_ntlmv2_hash(struct cifsSesInfo
*ses
,
348 const struct nls_table
*nls_cp
)
353 struct HMACMD5Context
*pctxt
;
357 pctxt
= kmalloc(sizeof(struct HMACMD5Context
), GFP_KERNEL
);
362 /* calculate md4 hash of password */
363 E_md4hash(ses
->password
, nt_hash
);
365 /* convert Domainname to unicode and uppercase */
366 hmac_md5_init_limK_to_64(nt_hash
, 16, pctxt
);
368 /* convert ses->userName to unicode and uppercase */
369 len
= strlen(ses
->userName
);
370 user
= kmalloc(2 + (len
* 2), GFP_KERNEL
);
373 len
= cifs_strtoUCS((__le16
*)user
, ses
->userName
, len
, nls_cp
);
375 hmac_md5_update((char *)user
, 2*len
, pctxt
);
377 /* convert ses->domainName to unicode and uppercase */
378 if (ses
->domainName
) {
379 len
= strlen(ses
->domainName
);
381 domain
= kmalloc(2 + (len
* 2), GFP_KERNEL
);
384 len
= cifs_strtoUCS((__le16
*)domain
, ses
->domainName
, len
,
386 /* the following line was removed since it didn't work well
387 with lower cased domain name that passed as an option.
388 Maybe converting the domain name earlier makes sense */
389 /* UniStrupr(domain); */
391 hmac_md5_update((char *)domain
, 2*len
, pctxt
);
398 /* BB FIXME what about bytes 24 through 40 of the signing key?
399 compare with the NTLM example */
400 hmac_md5_final(ses
->server
->ntlmv2_hash
, pctxt
);
407 setup_ntlmv2_rsp(struct cifsSesInfo
*ses
, char *resp_buf
,
408 const struct nls_table
*nls_cp
)
411 struct ntlmv2_resp
*buf
= (struct ntlmv2_resp
*)resp_buf
;
412 struct HMACMD5Context context
;
414 buf
->blob_signature
= cpu_to_le32(0x00000101);
416 buf
->time
= cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME
));
417 get_random_bytes(&buf
->client_chal
, sizeof(buf
->client_chal
));
420 if (ses
->server
->secType
== RawNTLMSSP
) {
421 if (!ses
->domainName
) {
422 rc
= find_domain_name(ses
);
424 cERROR(1, "error %d finding domain name", rc
);
425 goto setup_ntlmv2_rsp_ret
;
429 rc
= build_avpair_blob(ses
);
431 cERROR(1, "error %d building av pair blob", rc
);
436 /* calculate buf->ntlmv2_hash */
437 rc
= calc_ntlmv2_hash(ses
, nls_cp
);
439 cERROR(1, "could not get v2 hash rc %d", rc
);
440 goto setup_ntlmv2_rsp_ret
;
442 CalcNTLMv2_response(ses
, resp_buf
);
444 /* now calculate the MAC key for NTLMv2 */
445 hmac_md5_init_limK_to_64(ses
->server
->ntlmv2_hash
, 16, &context
);
446 hmac_md5_update(resp_buf
, 16, &context
);
447 hmac_md5_final(ses
->server
->session_key
.data
.ntlmv2
.key
, &context
);
449 memcpy(&ses
->server
->session_key
.data
.ntlmv2
.resp
, resp_buf
,
450 sizeof(struct ntlmv2_resp
));
451 ses
->server
->session_key
.len
= 16 + sizeof(struct ntlmv2_resp
);
455 setup_ntlmv2_rsp_ret
:
463 void CalcNTLMv2_response(const struct cifsSesInfo
*ses
,
464 char *v2_session_response
)
466 struct HMACMD5Context context
;
467 /* rest of v2 struct already generated */
468 memcpy(v2_session_response
+ 8, ses
->server
->cryptKey
, 8);
469 hmac_md5_init_limK_to_64(ses
->server
->ntlmv2_hash
, 16, &context
);
471 hmac_md5_update(v2_session_response
+8,
472 sizeof(struct ntlmv2_resp
) - 8, &context
);
475 hmac_md5_update(ses
->tiblob
, ses
->tilen
, &context
);
477 hmac_md5_final(v2_session_response
, &context
);
478 /* cifs_dump_mem("v2_sess_rsp: ", v2_session_response, 32); */