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
25 #include "cifs_debug.h"
27 #include "cifs_unicode.h"
28 #include "cifsproto.h"
29 #include <linux/ctype.h>
30 #include <linux/random.h>
32 /* Calculate and return the CIFS signature based on the mac key and 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 */
38 extern void mdfour(unsigned char *out
, unsigned char *in
, int n
);
39 extern void E_md4hash(const unsigned char *passwd
, unsigned char *p16
);
40 extern void SMBencrypt(unsigned char *passwd
, unsigned char *c8
,
43 static int cifs_calculate_signature(const struct smb_hdr
*cifs_pdu
,
44 const struct mac_key
*key
, char *signature
)
46 struct MD5Context context
;
48 if ((cifs_pdu
== NULL
) || (signature
== NULL
) || (key
== NULL
))
52 MD5Update(&context
, (char *)&key
->data
, key
->len
);
53 MD5Update(&context
, cifs_pdu
->Protocol
, cifs_pdu
->smb_buf_length
);
55 MD5Final(signature
, &context
);
59 int cifs_sign_smb(struct smb_hdr
*cifs_pdu
, struct TCP_Server_Info
*server
,
60 __u32
*pexpected_response_sequence_number
)
63 char smb_signature
[20];
65 if ((cifs_pdu
== NULL
) || (server
== NULL
))
68 if ((cifs_pdu
->Flags2
& SMBFLG2_SECURITY_SIGNATURE
) == 0)
71 spin_lock(&GlobalMid_Lock
);
72 cifs_pdu
->Signature
.Sequence
.SequenceNumber
=
73 cpu_to_le32(server
->sequence_number
);
74 cifs_pdu
->Signature
.Sequence
.Reserved
= 0;
76 *pexpected_response_sequence_number
= server
->sequence_number
++;
77 server
->sequence_number
++;
78 spin_unlock(&GlobalMid_Lock
);
80 rc
= cifs_calculate_signature(cifs_pdu
, &server
->mac_signing_key
,
83 memset(cifs_pdu
->Signature
.SecuritySignature
, 0, 8);
85 memcpy(cifs_pdu
->Signature
.SecuritySignature
, smb_signature
, 8);
90 static int cifs_calc_signature2(const struct kvec
*iov
, int n_vec
,
91 const struct mac_key
*key
, char *signature
)
93 struct MD5Context context
;
96 if ((iov
== NULL
) || (signature
== NULL
) || (key
== NULL
))
100 MD5Update(&context
, (char *)&key
->data
, key
->len
);
101 for (i
=0;i
<n_vec
;i
++) {
102 if (iov
[i
].iov_base
== NULL
) {
103 cERROR(1 ,("null iovec entry"));
105 } else if (iov
[i
].iov_len
== 0)
106 break; /* bail out if we are sent nothing to sign */
107 /* The first entry includes a length field (which does not get
108 signed that occupies the first 4 bytes before the header */
110 if (iov
[0].iov_len
<= 8 ) /* cmd field at offset 9 */
111 break; /* nothing to sign or corrupt header */
112 MD5Update(&context
,iov
[0].iov_base
+4, iov
[0].iov_len
-4);
114 MD5Update(&context
, iov
[i
].iov_base
, iov
[i
].iov_len
);
117 MD5Final(signature
, &context
);
123 int cifs_sign_smb2(struct kvec
*iov
, int n_vec
, struct TCP_Server_Info
*server
,
124 __u32
* pexpected_response_sequence_number
)
127 char smb_signature
[20];
128 struct smb_hdr
*cifs_pdu
= iov
[0].iov_base
;
130 if ((cifs_pdu
== NULL
) || (server
== NULL
))
133 if ((cifs_pdu
->Flags2
& SMBFLG2_SECURITY_SIGNATURE
) == 0)
136 spin_lock(&GlobalMid_Lock
);
137 cifs_pdu
->Signature
.Sequence
.SequenceNumber
=
138 cpu_to_le32(server
->sequence_number
);
139 cifs_pdu
->Signature
.Sequence
.Reserved
= 0;
141 *pexpected_response_sequence_number
= server
->sequence_number
++;
142 server
->sequence_number
++;
143 spin_unlock(&GlobalMid_Lock
);
145 rc
= cifs_calc_signature2(iov
, n_vec
, &server
->mac_signing_key
,
148 memset(cifs_pdu
->Signature
.SecuritySignature
, 0, 8);
150 memcpy(cifs_pdu
->Signature
.SecuritySignature
, smb_signature
, 8);
155 int cifs_verify_signature(struct smb_hdr
*cifs_pdu
,
156 const struct mac_key
*mac_key
,
157 __u32 expected_sequence_number
)
160 char server_response_sig
[8];
161 char what_we_think_sig_should_be
[20];
163 if ((cifs_pdu
== NULL
) || (mac_key
== NULL
))
166 if (cifs_pdu
->Command
== SMB_COM_NEGOTIATE
)
169 if (cifs_pdu
->Command
== SMB_COM_LOCKING_ANDX
) {
170 struct smb_com_lock_req
* pSMB
=
171 (struct smb_com_lock_req
*)cifs_pdu
;
172 if (pSMB
->LockType
& LOCKING_ANDX_OPLOCK_RELEASE
)
176 /* BB what if signatures are supposed to be on for session but server does not
179 /* Do not need to verify session setups with signature "BSRSPYL " */
180 if(memcmp(cifs_pdu
->Signature
.SecuritySignature
,"BSRSPYL ",8)==0)
181 cFYI(1,("dummy signature received for smb command 0x%x",cifs_pdu
->Command
));
183 /* save off the origiginal signature so we can modify the smb and check
184 its signature against what the server sent */
185 memcpy(server_response_sig
,cifs_pdu
->Signature
.SecuritySignature
,8);
187 cifs_pdu
->Signature
.Sequence
.SequenceNumber
= cpu_to_le32(expected_sequence_number
);
188 cifs_pdu
->Signature
.Sequence
.Reserved
= 0;
190 rc
= cifs_calculate_signature(cifs_pdu
, mac_key
,
191 what_we_think_sig_should_be
);
197 /* cifs_dump_mem("what we think it should be: ",what_we_think_sig_should_be,16); */
199 if(memcmp(server_response_sig
, what_we_think_sig_should_be
, 8))
206 /* We fill in key by putting in 40 byte array which was allocated by caller */
207 int cifs_calculate_mac_key(struct mac_key
*key
, const char *rn
,
208 const char *password
)
211 if ((key
== NULL
) || (rn
== NULL
))
214 E_md4hash(password
, temp_key
);
215 mdfour(key
->data
.ntlm
, temp_key
, 16);
216 memcpy(key
->data
.ntlm
+16, rn
, CIFS_SESS_KEY_SIZE
);
221 int CalcNTLMv2_partial_mac_key(struct cifsSesInfo
* ses
,
222 const struct nls_table
* nls_info
)
225 struct HMACMD5Context ctx
;
227 __le16
* unicode_buf
;
228 unsigned int i
,user_name_len
,dom_name_len
;
233 E_md4hash(ses
->password
, temp_hash
);
235 hmac_md5_init_limK_to_64(temp_hash
, 16, &ctx
);
236 user_name_len
= strlen(ses
->userName
);
237 if(user_name_len
> MAX_USERNAME_SIZE
)
239 if(ses
->domainName
== NULL
)
240 return -EINVAL
; /* BB should we use CIFS_LINUX_DOM */
241 dom_name_len
= strlen(ses
->domainName
);
242 if (dom_name_len
> MAX_USERNAME_SIZE
)
245 ucase_buf
= kmalloc((MAX_USERNAME_SIZE
+1), GFP_KERNEL
);
246 if (ucase_buf
== NULL
)
248 unicode_buf
= kmalloc((MAX_USERNAME_SIZE
+1)*4, GFP_KERNEL
);
249 if (unicode_buf
== NULL
) {
254 for (i
= 0;i
< user_name_len
; i
++)
255 ucase_buf
[i
] = nls_info
->charset2upper
[(int)ses
->userName
[i
]];
257 user_name_len
= cifs_strtoUCS(unicode_buf
, ucase_buf
, MAX_USERNAME_SIZE
*2, nls_info
);
258 unicode_buf
[user_name_len
] = 0;
261 for (i
= 0; i
< dom_name_len
; i
++)
262 ucase_buf
[i
] = nls_info
->charset2upper
[(int)ses
->domainName
[i
]];
264 dom_name_len
= cifs_strtoUCS(unicode_buf
+user_name_len
, ucase_buf
, MAX_USERNAME_SIZE
*2, nls_info
);
266 unicode_buf
[user_name_len
+ dom_name_len
] = 0;
267 hmac_md5_update((const unsigned char *) unicode_buf
,
268 (user_name_len
+dom_name_len
)*2, &ctx
);
270 hmac_md5_final(ses
->server
->ntlmv2_hash
, &ctx
);
276 #ifdef CONFIG_CIFS_WEAK_PW_HASH
277 void calc_lanman_hash(struct cifsSesInfo
* ses
, char * lnm_session_key
)
280 char password_with_pad
[CIFS_ENCPWD_SIZE
];
282 if(ses
->server
== NULL
)
285 memset(password_with_pad
, 0, CIFS_ENCPWD_SIZE
);
287 strncpy(password_with_pad
, ses
->password
, CIFS_ENCPWD_SIZE
);
289 if((ses
->server
->secMode
& SECMODE_PW_ENCRYPT
) == 0)
290 if(extended_security
& CIFSSEC_MAY_PLNTXT
) {
291 memcpy(lnm_session_key
, password_with_pad
, CIFS_ENCPWD_SIZE
);
295 /* calculate old style session key */
296 /* calling toupper is less broken than repeatedly
297 calling nls_toupper would be since that will never
298 work for UTF8, but neither handles multibyte code pages
299 but the only alternative would be converting to UCS-16 (Unicode)
300 (using a routine something like UniStrupr) then
301 uppercasing and then converting back from Unicode - which
302 would only worth doing it if we knew it were utf8. Basically
303 utf8 and other multibyte codepages each need their own strupper
304 function since a byte at a time will ont work. */
306 for(i
= 0; i
< CIFS_ENCPWD_SIZE
; i
++) {
307 password_with_pad
[i
] = toupper(password_with_pad
[i
]);
310 SMBencrypt(password_with_pad
, ses
->server
->cryptKey
, lnm_session_key
);
311 /* clear password before we return/free memory */
312 memset(password_with_pad
, 0, CIFS_ENCPWD_SIZE
);
314 #endif /* CIFS_WEAK_PW_HASH */
316 static int calc_ntlmv2_hash(struct cifsSesInfo
*ses
,
317 const struct nls_table
* nls_cp
)
322 struct HMACMD5Context
* pctxt
;
326 pctxt
= kmalloc(sizeof(struct HMACMD5Context
), GFP_KERNEL
);
331 /* calculate md4 hash of password */
332 E_md4hash(ses
->password
, nt_hash
);
334 /* convert Domainname to unicode and uppercase */
335 hmac_md5_init_limK_to_64(nt_hash
, 16, pctxt
);
337 /* convert ses->userName to unicode and uppercase */
338 len
= strlen(ses
->userName
);
339 user
= kmalloc(2 + (len
* 2), GFP_KERNEL
);
342 len
= cifs_strtoUCS(user
, ses
->userName
, len
, nls_cp
);
344 hmac_md5_update((char *)user
, 2*len
, pctxt
);
346 /* convert ses->domainName to unicode and uppercase */
347 if(ses
->domainName
) {
348 len
= strlen(ses
->domainName
);
350 domain
= kmalloc(2 + (len
* 2), GFP_KERNEL
);
353 len
= cifs_strtoUCS(domain
, ses
->domainName
, len
, nls_cp
);
354 /* the following line was removed since it didn't work well
355 with lower cased domain name that passed as an option.
356 Maybe converting the domain name earlier makes sense */
357 /* UniStrupr(domain); */
359 hmac_md5_update((char *)domain
, 2*len
, pctxt
);
366 /* BB FIXME what about bytes 24 through 40 of the signing key?
367 compare with the NTLM example */
368 hmac_md5_final(ses
->server
->ntlmv2_hash
, pctxt
);
373 void setup_ntlmv2_rsp(struct cifsSesInfo
* ses
, char * resp_buf
,
374 const struct nls_table
* nls_cp
)
377 struct ntlmv2_resp
* buf
= (struct ntlmv2_resp
*)resp_buf
;
378 struct HMACMD5Context context
;
380 buf
->blob_signature
= cpu_to_le32(0x00000101);
382 buf
->time
= cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME
));
383 get_random_bytes(&buf
->client_chal
, sizeof(buf
->client_chal
));
385 buf
->names
[0].type
= cpu_to_le16(NTLMSSP_DOMAIN_TYPE
);
386 buf
->names
[0].length
= 0;
387 buf
->names
[1].type
= 0;
388 buf
->names
[1].length
= 0;
390 /* calculate buf->ntlmv2_hash */
391 rc
= calc_ntlmv2_hash(ses
, nls_cp
);
393 cERROR(1,("could not get v2 hash rc %d",rc
));
394 CalcNTLMv2_response(ses
, resp_buf
);
396 /* now calculate the MAC key for NTLMv2 */
397 hmac_md5_init_limK_to_64(ses
->server
->ntlmv2_hash
, 16, &context
);
398 hmac_md5_update(resp_buf
, 16, &context
);
399 hmac_md5_final(ses
->server
->mac_signing_key
.data
.ntlmv2
.key
, &context
);
401 memcpy(&ses
->server
->mac_signing_key
.data
.ntlmv2
.resp
, resp_buf
,
402 sizeof(struct ntlmv2_resp
));
403 ses
->server
->mac_signing_key
.len
= 16 + sizeof(struct ntlmv2_resp
);
406 void CalcNTLMv2_response(const struct cifsSesInfo
* ses
, char * v2_session_response
)
408 struct HMACMD5Context context
;
409 /* rest of v2 struct already generated */
410 memcpy(v2_session_response
+ 8, ses
->server
->cryptKey
,8);
411 hmac_md5_init_limK_to_64(ses
->server
->ntlmv2_hash
, 16, &context
);
413 hmac_md5_update(v2_session_response
+8,
414 sizeof(struct ntlmv2_resp
) - 8, &context
);
416 hmac_md5_final(v2_session_response
,&context
);
417 /* cifs_dump_mem("v2_sess_rsp: ", v2_session_response, 32); */