blob: 66bd7fa9b7a6f739f7f5fda0d0b6fe4c79192a47 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/cifsencrypt.c
3 *
Steve French8b7a4542015-03-30 16:58:17 -05004 * Encryption and hashing operations relating to NTLM, NTLMv2. See MS-NLMP
5 * for more detailed information
6 *
Steve French95dc8dd2013-07-04 10:35:21 -05007 * Copyright (C) International Business Machines Corp., 2005,2013
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * Author(s): Steve French (sfrench@us.ibm.com)
9 *
10 * This library is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU Lesser General Public License as published
12 * by the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24
25#include <linux/fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090026#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "cifspdu.h"
Steve Frenchffdd6e42007-06-24 21:15:44 +000028#include "cifsglob.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "cifs_debug.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include "cifs_unicode.h"
31#include "cifsproto.h"
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -050032#include "ntlmssp.h"
Steve French7c7b25b2006-06-01 19:20:10 +000033#include <linux/ctype.h>
Steve French6d027cf2006-06-05 16:26:05 +000034#include <linux/random.h>
Jeff Laytonfb308a62012-09-18 16:20:35 -070035#include <linux/highmem.h>
Herbert Xu9651ddb2016-01-24 21:17:17 +080036#include <crypto/skcipher.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Steve French95dc8dd2013-07-04 10:35:21 -050038static int
39cifs_crypto_shash_md5_allocate(struct TCP_Server_Info *server)
40{
41 int rc;
42 unsigned int size;
43
44 if (server->secmech.sdescmd5 != NULL)
45 return 0; /* already allocated */
46
47 server->secmech.md5 = crypto_alloc_shash("md5", 0, 0);
48 if (IS_ERR(server->secmech.md5)) {
49 cifs_dbg(VFS, "could not allocate crypto md5\n");
Jeff Laytonba482022013-07-31 13:48:00 -040050 rc = PTR_ERR(server->secmech.md5);
51 server->secmech.md5 = NULL;
52 return rc;
Steve French95dc8dd2013-07-04 10:35:21 -050053 }
54
55 size = sizeof(struct shash_desc) +
56 crypto_shash_descsize(server->secmech.md5);
57 server->secmech.sdescmd5 = kmalloc(size, GFP_KERNEL);
58 if (!server->secmech.sdescmd5) {
Steve French95dc8dd2013-07-04 10:35:21 -050059 crypto_free_shash(server->secmech.md5);
60 server->secmech.md5 = NULL;
Jeff Laytonba482022013-07-31 13:48:00 -040061 return -ENOMEM;
Steve French95dc8dd2013-07-04 10:35:21 -050062 }
63 server->secmech.sdescmd5->shash.tfm = server->secmech.md5;
64 server->secmech.sdescmd5->shash.flags = 0x0;
65
66 return 0;
67}
68
Al Viro16c568e2015-11-12 22:46:49 -050069int __cifs_calc_signature(struct smb_rqst *rqst,
70 struct TCP_Server_Info *server, char *signature,
71 struct shash_desc *shash)
72{
73 int i;
74 int rc;
75 struct kvec *iov = rqst->rq_iov;
76 int n_vec = rqst->rq_nvec;
77
78 for (i = 0; i < n_vec; i++) {
79 if (iov[i].iov_len == 0)
80 continue;
81 if (iov[i].iov_base == NULL) {
82 cifs_dbg(VFS, "null iovec entry\n");
83 return -EIO;
84 }
85 /* The first entry includes a length field (which does not get
86 signed that occupies the first 4 bytes before the header */
87 if (i == 0) {
88 if (iov[0].iov_len <= 8) /* cmd field at offset 9 */
89 break; /* nothing to sign or corrupt header */
90 rc = crypto_shash_update(shash,
91 iov[i].iov_base + 4, iov[i].iov_len - 4);
92 } else {
93 rc = crypto_shash_update(shash,
94 iov[i].iov_base, iov[i].iov_len);
95 }
96 if (rc) {
97 cifs_dbg(VFS, "%s: Could not update with payload\n",
98 __func__);
99 return rc;
100 }
101 }
102
103 /* now hash over the rq_pages array */
104 for (i = 0; i < rqst->rq_npages; i++) {
105 void *kaddr = kmap(rqst->rq_pages[i]);
106 size_t len = rqst->rq_pagesz;
107
108 if (i == rqst->rq_npages - 1)
109 len = rqst->rq_tailsz;
110
111 crypto_shash_update(shash, kaddr, len);
112
113 kunmap(rqst->rq_pages[i]);
114 }
115
116 rc = crypto_shash_final(shash, signature);
117 if (rc)
118 cifs_dbg(VFS, "%s: Could not generate hash\n", __func__);
119
120 return rc;
121}
122
Jeff Layton157c2492011-04-02 07:34:30 -0400123/*
124 * Calculate and return the CIFS signature based on the mac key and SMB PDU.
125 * The 16 byte signature must be allocated by the caller. Note we only use the
126 * 1st eight bytes and that the smb header signature field on input contains
127 * the sequence number before this function is called. Also, this function
128 * should be called with the server->srv_mutex held.
129 */
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700130static int cifs_calc_signature(struct smb_rqst *rqst,
Jeff Layton826a95e2011-10-11 06:41:32 -0400131 struct TCP_Server_Info *server, char *signature)
Steve French84afc292005-12-02 13:32:45 -0800132{
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500133 int rc;
Steve French84afc292005-12-02 13:32:45 -0800134
Al Viro16c568e2015-11-12 22:46:49 -0500135 if (!rqst->rq_iov || !signature || !server)
Steve Frenche9917a02006-03-31 21:22:00 +0000136 return -EINVAL;
Steve French84afc292005-12-02 13:32:45 -0800137
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500138 if (!server->secmech.sdescmd5) {
Steve French95dc8dd2013-07-04 10:35:21 -0500139 rc = cifs_crypto_shash_md5_allocate(server);
140 if (rc) {
141 cifs_dbg(VFS, "%s: Can't alloc md5 crypto\n", __func__);
142 return -1;
143 }
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500144 }
145
146 rc = crypto_shash_init(&server->secmech.sdescmd5->shash);
147 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500148 cifs_dbg(VFS, "%s: Could not init md5\n", __func__);
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500149 return rc;
150 }
151
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500152 rc = crypto_shash_update(&server->secmech.sdescmd5->shash,
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500153 server->session_key.response, server->session_key.len);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500154 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500155 cifs_dbg(VFS, "%s: Could not update with response\n", __func__);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500156 return rc;
157 }
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500158
Al Viro16c568e2015-11-12 22:46:49 -0500159 return __cifs_calc_signature(rqst, server, signature,
160 &server->secmech.sdescmd5->shash);
Steve French84afc292005-12-02 13:32:45 -0800161}
162
Jeff Laytona0f8b4f2011-01-07 11:30:28 -0500163/* must be called with server->srv_mutex held */
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700164int cifs_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server,
Steve French63d25832007-11-05 21:46:10 +0000165 __u32 *pexpected_response_sequence_number)
Steve French84afc292005-12-02 13:32:45 -0800166{
167 int rc = 0;
168 char smb_signature[20];
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700169 struct smb_hdr *cifs_pdu = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
Steve French84afc292005-12-02 13:32:45 -0800170
Steve Frenchffdd6e42007-06-24 21:15:44 +0000171 if ((cifs_pdu == NULL) || (server == NULL))
Steve French84afc292005-12-02 13:32:45 -0800172 return -EINVAL;
173
Jeff Layton998d6fc2011-07-26 12:21:17 -0400174 if (!(cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) ||
175 server->tcpStatus == CifsNeedNegotiate)
Steve French84afc292005-12-02 13:32:45 -0800176 return rc;
177
Jeff Layton998d6fc2011-07-26 12:21:17 -0400178 if (!server->session_estab) {
Jeff Laytonb4dacbc2011-10-11 06:41:32 -0400179 memcpy(cifs_pdu->Signature.SecuritySignature, "BSRSPYL", 8);
Jeff Layton998d6fc2011-07-26 12:21:17 -0400180 return rc;
181 }
182
Steve Frenchffdd6e42007-06-24 21:15:44 +0000183 cifs_pdu->Signature.Sequence.SequenceNumber =
Steve French84afc292005-12-02 13:32:45 -0800184 cpu_to_le32(server->sequence_number);
Steve Frenchffdd6e42007-06-24 21:15:44 +0000185 cifs_pdu->Signature.Sequence.Reserved = 0;
Steve French84afc292005-12-02 13:32:45 -0800186
Jeff Layton0124cc42013-04-03 11:55:03 -0400187 *pexpected_response_sequence_number = ++server->sequence_number;
188 ++server->sequence_number;
Steve French84afc292005-12-02 13:32:45 -0800189
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700190 rc = cifs_calc_signature(rqst, server, smb_signature);
Steve Frenchffdd6e42007-06-24 21:15:44 +0000191 if (rc)
192 memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
193 else
194 memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8);
Steve French84afc292005-12-02 13:32:45 -0800195
Steve Frenchffdd6e42007-06-24 21:15:44 +0000196 return rc;
Steve French84afc292005-12-02 13:32:45 -0800197}
198
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700199int cifs_sign_smbv(struct kvec *iov, int n_vec, struct TCP_Server_Info *server,
200 __u32 *pexpected_response_sequence)
201{
202 struct smb_rqst rqst = { .rq_iov = iov,
203 .rq_nvec = n_vec };
204
205 return cifs_sign_rqst(&rqst, server, pexpected_response_sequence);
206}
207
Jeff Layton826a95e2011-10-11 06:41:32 -0400208/* must be called with server->srv_mutex held */
209int cifs_sign_smb(struct smb_hdr *cifs_pdu, struct TCP_Server_Info *server,
210 __u32 *pexpected_response_sequence_number)
211{
212 struct kvec iov;
213
214 iov.iov_base = cifs_pdu;
215 iov.iov_len = be32_to_cpu(cifs_pdu->smb_buf_length) + 4;
216
Jeff Layton762a4202012-07-23 13:28:38 -0400217 return cifs_sign_smbv(&iov, 1, server,
Jeff Layton826a95e2011-10-11 06:41:32 -0400218 pexpected_response_sequence_number);
219}
220
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700221int cifs_verify_signature(struct smb_rqst *rqst,
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500222 struct TCP_Server_Info *server,
Steve Frenchffdd6e42007-06-24 21:15:44 +0000223 __u32 expected_sequence_number)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224{
Steve Frenchc8e56f12010-09-08 21:10:58 +0000225 unsigned int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 char server_response_sig[8];
227 char what_we_think_sig_should_be[20];
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700228 struct smb_hdr *cifs_pdu = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500230 if (cifs_pdu == NULL || server == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 return -EINVAL;
232
Jeff Layton9c4843e2011-06-06 15:40:23 -0400233 if (!server->session_estab)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 return 0;
235
236 if (cifs_pdu->Command == SMB_COM_LOCKING_ANDX) {
Steve French50c2f752007-07-13 00:33:32 +0000237 struct smb_com_lock_req *pSMB =
Steve Frenchffdd6e42007-06-24 21:15:44 +0000238 (struct smb_com_lock_req *)cifs_pdu;
239 if (pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 return 0;
241 }
242
Steve French50c2f752007-07-13 00:33:32 +0000243 /* BB what if signatures are supposed to be on for session but
244 server does not send one? BB */
245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 /* Do not need to verify session setups with signature "BSRSPYL " */
Steve French50c2f752007-07-13 00:33:32 +0000247 if (memcmp(cifs_pdu->Signature.SecuritySignature, "BSRSPYL ", 8) == 0)
Joe Perchesf96637b2013-05-04 22:12:25 -0500248 cifs_dbg(FYI, "dummy signature received for smb command 0x%x\n",
249 cifs_pdu->Command);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
251 /* save off the origiginal signature so we can modify the smb and check
252 its signature against what the server sent */
Steve French50c2f752007-07-13 00:33:32 +0000253 memcpy(server_response_sig, cifs_pdu->Signature.SecuritySignature, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
Steve French50c2f752007-07-13 00:33:32 +0000255 cifs_pdu->Signature.Sequence.SequenceNumber =
256 cpu_to_le32(expected_sequence_number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 cifs_pdu->Signature.Sequence.Reserved = 0;
258
Jeff Layton157c2492011-04-02 07:34:30 -0400259 mutex_lock(&server->srv_mutex);
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700260 rc = cifs_calc_signature(rqst, server, what_we_think_sig_should_be);
Jeff Layton157c2492011-04-02 07:34:30 -0400261 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
Steve French50c2f752007-07-13 00:33:32 +0000263 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 return rc;
265
Steve French50c2f752007-07-13 00:33:32 +0000266/* cifs_dump_mem("what we think it should be: ",
267 what_we_think_sig_should_be, 16); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
Steve French50c2f752007-07-13 00:33:32 +0000269 if (memcmp(server_response_sig, what_we_think_sig_should_be, 8))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 return -EACCES;
271 else
272 return 0;
273
274}
275
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500276/* first calculate 24 bytes ntlm response and then 16 byte session key */
Shirish Pargaonkar9ef59922011-10-20 13:21:59 -0500277int setup_ntlm_response(struct cifs_ses *ses, const struct nls_table *nls_cp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278{
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -0600279 int rc = 0;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500280 unsigned int temp_len = CIFS_SESS_KEY_SIZE + CIFS_AUTH_RESP_SIZE;
281 char temp_key[CIFS_SESS_KEY_SIZE];
282
283 if (!ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 return -EINVAL;
285
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500286 ses->auth_key.response = kmalloc(temp_len, GFP_KERNEL);
Joe Perchesf96637b2013-05-04 22:12:25 -0500287 if (!ses->auth_key.response)
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500288 return -ENOMEM;
Joe Perchesf96637b2013-05-04 22:12:25 -0500289
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500290 ses->auth_key.len = temp_len;
291
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -0600292 rc = SMBNTencrypt(ses->password, ses->server->cryptkey,
Shirish Pargaonkar9ef59922011-10-20 13:21:59 -0500293 ses->auth_key.response + CIFS_SESS_KEY_SIZE, nls_cp);
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -0600294 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500295 cifs_dbg(FYI, "%s Can't generate NTLM response, error: %d\n",
296 __func__, rc);
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -0600297 return rc;
298 }
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500299
Shirish Pargaonkar9ef59922011-10-20 13:21:59 -0500300 rc = E_md4hash(ses->password, temp_key, nls_cp);
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -0600301 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500302 cifs_dbg(FYI, "%s Can't generate NT hash, error: %d\n",
303 __func__, rc);
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -0600304 return rc;
305 }
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500306
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -0600307 rc = mdfour(ses->auth_key.response, temp_key, CIFS_SESS_KEY_SIZE);
308 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500309 cifs_dbg(FYI, "%s Can't generate NTLM session key, error: %d\n",
310 __func__, rc);
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -0600311
312 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313}
314
Steve French7c7b25b2006-06-01 19:20:10 +0000315#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French43988d72011-04-19 18:23:31 +0000316int calc_lanman_hash(const char *password, const char *cryptkey, bool encrypt,
Jeff Layton4e53a3f2008-12-05 20:41:21 -0500317 char *lnm_session_key)
Steve French7c7b25b2006-06-01 19:20:10 +0000318{
319 int i;
Steve French43988d72011-04-19 18:23:31 +0000320 int rc;
Steve French7c7b25b2006-06-01 19:20:10 +0000321 char password_with_pad[CIFS_ENCPWD_SIZE];
322
323 memset(password_with_pad, 0, CIFS_ENCPWD_SIZE);
Jeff Layton4e53a3f2008-12-05 20:41:21 -0500324 if (password)
325 strncpy(password_with_pad, password, CIFS_ENCPWD_SIZE);
Steve French7c7b25b2006-06-01 19:20:10 +0000326
Jeff Layton04912d62010-04-24 07:57:45 -0400327 if (!encrypt && global_secflags & CIFSSEC_MAY_PLNTXT) {
Jeff Layton4e53a3f2008-12-05 20:41:21 -0500328 memcpy(lnm_session_key, password_with_pad,
329 CIFS_ENCPWD_SIZE);
Steve French43988d72011-04-19 18:23:31 +0000330 return 0;
Jeff Layton4e53a3f2008-12-05 20:41:21 -0500331 }
Steve Frenchbdc4bf6e2006-06-02 22:57:13 +0000332
Steve French7c7b25b2006-06-01 19:20:10 +0000333 /* calculate old style session key */
334 /* calling toupper is less broken than repeatedly
335 calling nls_toupper would be since that will never
336 work for UTF8, but neither handles multibyte code pages
337 but the only alternative would be converting to UCS-16 (Unicode)
338 (using a routine something like UniStrupr) then
339 uppercasing and then converting back from Unicode - which
340 would only worth doing it if we knew it were utf8. Basically
341 utf8 and other multibyte codepages each need their own strupper
342 function since a byte at a time will ont work. */
343
Shirish Pargaonkaref571ca2008-07-24 15:56:05 +0000344 for (i = 0; i < CIFS_ENCPWD_SIZE; i++)
Steve French7c7b25b2006-06-01 19:20:10 +0000345 password_with_pad[i] = toupper(password_with_pad[i]);
Steve French7c7b25b2006-06-01 19:20:10 +0000346
Steve French43988d72011-04-19 18:23:31 +0000347 rc = SMBencrypt(password_with_pad, cryptkey, lnm_session_key);
Jeff Layton4e53a3f2008-12-05 20:41:21 -0500348
Steve French43988d72011-04-19 18:23:31 +0000349 return rc;
Steve French7c7b25b2006-06-01 19:20:10 +0000350}
351#endif /* CIFS_WEAK_PW_HASH */
352
Shirish Pargaonkar9daa42e2010-10-10 13:21:05 -0500353/* Build a proper attribute value/target info pairs blob.
354 * Fill in netbios and dns domain name and workstation name
355 * and client time (total five av pairs and + one end of fields indicator.
356 * Allocate domain name which gets freed when session struct is deallocated.
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500357 */
358static int
Steve French96daf2b2011-05-27 04:34:02 +0000359build_avpair_blob(struct cifs_ses *ses, const struct nls_table *nls_cp)
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500360{
Shirish Pargaonkar9daa42e2010-10-10 13:21:05 -0500361 unsigned int dlen;
Shirish Pargaonkarcfbd6f82011-08-24 23:05:46 -0500362 unsigned int size = 2 * sizeof(struct ntlmssp2_name);
Shirish Pargaonkar9daa42e2010-10-10 13:21:05 -0500363 char *defdmname = "WORKGROUP";
364 unsigned char *blobptr;
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500365 struct ntlmssp2_name *attrptr;
366
Shirish Pargaonkar9daa42e2010-10-10 13:21:05 -0500367 if (!ses->domainName) {
368 ses->domainName = kstrdup(defdmname, GFP_KERNEL);
369 if (!ses->domainName)
370 return -ENOMEM;
371 }
372
373 dlen = strlen(ses->domainName);
Shirish Pargaonkar9daa42e2010-10-10 13:21:05 -0500374
Shirish Pargaonkarcfbd6f82011-08-24 23:05:46 -0500375 /*
376 * The length of this blob is two times the size of a
377 * structure (av pair) which holds name/size
378 * ( for NTLMSSP_AV_NB_DOMAIN_NAME followed by NTLMSSP_AV_EOL ) +
379 * unicode length of a netbios domain name
Shirish Pargaonkar9daa42e2010-10-10 13:21:05 -0500380 */
Shirish Pargaonkarcfbd6f82011-08-24 23:05:46 -0500381 ses->auth_key.len = size + 2 * dlen;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500382 ses->auth_key.response = kzalloc(ses->auth_key.len, GFP_KERNEL);
383 if (!ses->auth_key.response) {
384 ses->auth_key.len = 0;
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500385 return -ENOMEM;
386 }
Shirish Pargaonkar9daa42e2010-10-10 13:21:05 -0500387
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500388 blobptr = ses->auth_key.response;
Shirish Pargaonkar9daa42e2010-10-10 13:21:05 -0500389 attrptr = (struct ntlmssp2_name *) blobptr;
390
Shirish Pargaonkarcfbd6f82011-08-24 23:05:46 -0500391 /*
392 * As defined in MS-NTLM 3.3.2, just this av pair field
393 * is sufficient as part of the temp
394 */
Shirish Pargaonkar9daa42e2010-10-10 13:21:05 -0500395 attrptr->type = cpu_to_le16(NTLMSSP_AV_NB_DOMAIN_NAME);
396 attrptr->length = cpu_to_le16(2 * dlen);
397 blobptr = (unsigned char *)attrptr + sizeof(struct ntlmssp2_name);
Steve Frenchacbbb762012-01-18 22:32:33 -0600398 cifs_strtoUTF16((__le16 *)blobptr, ses->domainName, dlen, nls_cp);
Shirish Pargaonkar9daa42e2010-10-10 13:21:05 -0500399
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500400 return 0;
401}
402
403/* Server has provided av pairs/target info in the type 2 challenge
404 * packet and we have plucked it and stored within smb session.
405 * We parse that blob here to find netbios domain name to be used
406 * as part of ntlmv2 authentication (in Target String), if not already
407 * specified on the command line.
408 * If this function returns without any error but without fetching
409 * domain name, authentication may fail against some server but
410 * may not fail against other (those who are not very particular
411 * about target string i.e. for some, just user name might suffice.
412 */
413static int
Steve French96daf2b2011-05-27 04:34:02 +0000414find_domain_name(struct cifs_ses *ses, const struct nls_table *nls_cp)
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500415{
416 unsigned int attrsize;
417 unsigned int type;
418 unsigned int onesize = sizeof(struct ntlmssp2_name);
419 unsigned char *blobptr;
420 unsigned char *blobend;
421 struct ntlmssp2_name *attrptr;
422
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500423 if (!ses->auth_key.len || !ses->auth_key.response)
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500424 return 0;
425
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500426 blobptr = ses->auth_key.response;
427 blobend = blobptr + ses->auth_key.len;
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500428
429 while (blobptr + onesize < blobend) {
430 attrptr = (struct ntlmssp2_name *) blobptr;
431 type = le16_to_cpu(attrptr->type);
432 if (type == NTLMSSP_AV_EOL)
433 break;
434 blobptr += 2; /* advance attr type */
435 attrsize = le16_to_cpu(attrptr->length);
436 blobptr += 2; /* advance attr size */
437 if (blobptr + attrsize > blobend)
438 break;
439 if (type == NTLMSSP_AV_NB_DOMAIN_NAME) {
Chen Gang057d6332013-07-19 09:01:36 +0800440 if (!attrsize || attrsize >= CIFS_MAX_DOMAINNAME_LEN)
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500441 break;
442 if (!ses->domainName) {
443 ses->domainName =
444 kmalloc(attrsize + 1, GFP_KERNEL);
445 if (!ses->domainName)
446 return -ENOMEM;
Steve Frenchacbbb762012-01-18 22:32:33 -0600447 cifs_from_utf16(ses->domainName,
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500448 (__le16 *)blobptr, attrsize, attrsize,
Steve Frenchb6938552014-09-25 13:20:05 -0500449 nls_cp, NO_MAP_UNI_RSVD);
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500450 break;
451 }
452 }
453 blobptr += attrsize; /* advance attr value */
454 }
455
456 return 0;
457}
458
Peter Seiderer98ce94c2015-09-17 21:40:12 +0200459/* Server has provided av pairs/target info in the type 2 challenge
460 * packet and we have plucked it and stored within smb session.
461 * We parse that blob here to find the server given timestamp
462 * as part of ntlmv2 authentication (or local current time as
463 * default in case of failure)
464 */
465static __le64
466find_timestamp(struct cifs_ses *ses)
467{
468 unsigned int attrsize;
469 unsigned int type;
470 unsigned int onesize = sizeof(struct ntlmssp2_name);
471 unsigned char *blobptr;
472 unsigned char *blobend;
473 struct ntlmssp2_name *attrptr;
474
475 if (!ses->auth_key.len || !ses->auth_key.response)
476 return 0;
477
478 blobptr = ses->auth_key.response;
479 blobend = blobptr + ses->auth_key.len;
480
481 while (blobptr + onesize < blobend) {
482 attrptr = (struct ntlmssp2_name *) blobptr;
483 type = le16_to_cpu(attrptr->type);
484 if (type == NTLMSSP_AV_EOL)
485 break;
486 blobptr += 2; /* advance attr type */
487 attrsize = le16_to_cpu(attrptr->length);
488 blobptr += 2; /* advance attr size */
489 if (blobptr + attrsize > blobend)
490 break;
491 if (type == NTLMSSP_AV_TIMESTAMP) {
492 if (attrsize == sizeof(u64))
493 return *((__le64 *)blobptr);
494 }
495 blobptr += attrsize; /* advance attr value */
496 }
497
498 return cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
499}
500
Steve French96daf2b2011-05-27 04:34:02 +0000501static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
Steve French50c2f752007-07-13 00:33:32 +0000502 const struct nls_table *nls_cp)
Steve Frencha8ee0342006-06-05 23:34:19 +0000503{
504 int rc = 0;
505 int len;
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500506 char nt_hash[CIFS_NTHASH_SIZE];
Steve Frenchfdf96a92013-06-25 14:03:16 -0500507 __le16 *user;
Steve French50c2f752007-07-13 00:33:32 +0000508 wchar_t *domain;
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500509 wchar_t *server;
Steve Frenchc8e56f12010-09-08 21:10:58 +0000510
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500511 if (!ses->server->secmech.sdeschmacmd5) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500512 cifs_dbg(VFS, "%s: can't generate ntlmv2 hash\n", __func__);
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500513 return -1;
514 }
Steve Frencha8ee0342006-06-05 23:34:19 +0000515
516 /* calculate md4 hash of password */
Shirish Pargaonkar9ef59922011-10-20 13:21:59 -0500517 E_md4hash(ses->password, nt_hash, nls_cp);
Steve Frencha8ee0342006-06-05 23:34:19 +0000518
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500519 rc = crypto_shash_setkey(ses->server->secmech.hmacmd5, nt_hash,
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500520 CIFS_NTHASH_SIZE);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500521 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500522 cifs_dbg(VFS, "%s: Could not set NT Hash as a key\n", __func__);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500523 return rc;
524 }
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500525
526 rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);
527 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500528 cifs_dbg(VFS, "%s: could not init hmacmd5\n", __func__);
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500529 return rc;
530 }
Steve Frencha8ee0342006-06-05 23:34:19 +0000531
Steve Frenchfdf96a92013-06-25 14:03:16 -0500532 /* convert ses->user_name to unicode */
Jeff Layton04febab2012-01-17 16:09:15 -0500533 len = ses->user_name ? strlen(ses->user_name) : 0;
Steve French1717ffc2006-06-08 05:41:32 +0000534 user = kmalloc(2 + (len * 2), GFP_KERNEL);
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500535 if (user == NULL) {
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500536 rc = -ENOMEM;
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500537 return rc;
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500538 }
Jeff Layton04febab2012-01-17 16:09:15 -0500539
540 if (len) {
Steve Frenchfdf96a92013-06-25 14:03:16 -0500541 len = cifs_strtoUTF16(user, ses->user_name, len, nls_cp);
Jeff Layton04febab2012-01-17 16:09:15 -0500542 UniStrupr(user);
543 } else {
544 memset(user, '\0', 2);
545 }
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500546
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500547 rc = crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500548 (char *)user, 2 * len);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500549 kfree(user);
550 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500551 cifs_dbg(VFS, "%s: Could not update with user\n", __func__);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500552 return rc;
553 }
Steve Frencha8ee0342006-06-05 23:34:19 +0000554
555 /* convert ses->domainName to unicode and uppercase */
Steve French50c2f752007-07-13 00:33:32 +0000556 if (ses->domainName) {
Steve French1717ffc2006-06-08 05:41:32 +0000557 len = strlen(ses->domainName);
Steve Frencha8ee0342006-06-05 23:34:19 +0000558
Steve French50c2f752007-07-13 00:33:32 +0000559 domain = kmalloc(2 + (len * 2), GFP_KERNEL);
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500560 if (domain == NULL) {
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500561 rc = -ENOMEM;
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500562 return rc;
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500563 }
Steve Frenchacbbb762012-01-18 22:32:33 -0600564 len = cifs_strtoUTF16((__le16 *)domain, ses->domainName, len,
565 nls_cp);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500566 rc =
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500567 crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
568 (char *)domain, 2 * len);
Steve French1717ffc2006-06-08 05:41:32 +0000569 kfree(domain);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500570 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500571 cifs_dbg(VFS, "%s: Could not update with domain\n",
572 __func__);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500573 return rc;
574 }
Steve French8b7a4542015-03-30 16:58:17 -0500575 } else {
576 /* We use ses->serverName if no domain name available */
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500577 len = strlen(ses->serverName);
578
579 server = kmalloc(2 + (len * 2), GFP_KERNEL);
580 if (server == NULL) {
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500581 rc = -ENOMEM;
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500582 return rc;
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500583 }
Steve Frenchacbbb762012-01-18 22:32:33 -0600584 len = cifs_strtoUTF16((__le16 *)server, ses->serverName, len,
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500585 nls_cp);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500586 rc =
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500587 crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
588 (char *)server, 2 * len);
589 kfree(server);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500590 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500591 cifs_dbg(VFS, "%s: Could not update with server\n",
592 __func__);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500593 return rc;
594 }
Steve French1717ffc2006-06-08 05:41:32 +0000595 }
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500596
597 rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500598 ntlmv2_hash);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500599 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500600 cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500601
Steve Frencha8ee0342006-06-05 23:34:19 +0000602 return rc;
603}
604
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500605static int
Steve French96daf2b2011-05-27 04:34:02 +0000606CalcNTLMv2_response(const struct cifs_ses *ses, char *ntlmv2_hash)
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500607{
608 int rc;
Tim Gardner2c957dd2013-11-07 16:40:57 -0700609 struct ntlmv2_resp *ntlmv2 = (struct ntlmv2_resp *)
610 (ses->auth_key.response + CIFS_SESS_KEY_SIZE);
611 unsigned int hash_len;
612
613 /* The MD5 hash starts at challenge_key.key */
614 hash_len = ses->auth_key.len - (CIFS_SESS_KEY_SIZE +
615 offsetof(struct ntlmv2_resp, challenge.key[0]));
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500616
617 if (!ses->server->secmech.sdeschmacmd5) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500618 cifs_dbg(VFS, "%s: can't generate ntlmv2 hash\n", __func__);
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500619 return -1;
620 }
621
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500622 rc = crypto_shash_setkey(ses->server->secmech.hmacmd5,
Tim Gardner2c957dd2013-11-07 16:40:57 -0700623 ntlmv2_hash, CIFS_HMAC_MD5_HASH_SIZE);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500624 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500625 cifs_dbg(VFS, "%s: Could not set NTLMV2 Hash as a key\n",
626 __func__);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500627 return rc;
628 }
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500629
630 rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);
631 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500632 cifs_dbg(VFS, "%s: could not init hmacmd5\n", __func__);
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500633 return rc;
634 }
635
Jeff Layton3f618222013-06-12 19:52:14 -0500636 if (ses->server->negflavor == CIFS_NEGFLAVOR_EXTENDED)
Tim Gardner2c957dd2013-11-07 16:40:57 -0700637 memcpy(ntlmv2->challenge.key,
638 ses->ntlmssp->cryptkey, CIFS_SERVER_CHALLENGE_SIZE);
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -0500639 else
Tim Gardner2c957dd2013-11-07 16:40:57 -0700640 memcpy(ntlmv2->challenge.key,
641 ses->server->cryptkey, CIFS_SERVER_CHALLENGE_SIZE);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500642 rc = crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
Tim Gardner2c957dd2013-11-07 16:40:57 -0700643 ntlmv2->challenge.key, hash_len);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500644 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500645 cifs_dbg(VFS, "%s: Could not update with response\n", __func__);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500646 return rc;
647 }
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500648
Tim Gardner2c957dd2013-11-07 16:40:57 -0700649 /* Note that the MD5 digest over writes anon.challenge_key.key */
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500650 rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,
Tim Gardner2c957dd2013-11-07 16:40:57 -0700651 ntlmv2->ntlmv2_hash);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500652 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500653 cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500654
655 return rc;
656}
657
Steve French95dc8dd2013-07-04 10:35:21 -0500658static int crypto_hmacmd5_alloc(struct TCP_Server_Info *server)
659{
Jeff Laytonba482022013-07-31 13:48:00 -0400660 int rc;
Steve French95dc8dd2013-07-04 10:35:21 -0500661 unsigned int size;
662
663 /* check if already allocated */
664 if (server->secmech.sdeschmacmd5)
665 return 0;
666
667 server->secmech.hmacmd5 = crypto_alloc_shash("hmac(md5)", 0, 0);
668 if (IS_ERR(server->secmech.hmacmd5)) {
669 cifs_dbg(VFS, "could not allocate crypto hmacmd5\n");
Jeff Laytonba482022013-07-31 13:48:00 -0400670 rc = PTR_ERR(server->secmech.hmacmd5);
671 server->secmech.hmacmd5 = NULL;
672 return rc;
Steve French95dc8dd2013-07-04 10:35:21 -0500673 }
674
675 size = sizeof(struct shash_desc) +
676 crypto_shash_descsize(server->secmech.hmacmd5);
677 server->secmech.sdeschmacmd5 = kmalloc(size, GFP_KERNEL);
678 if (!server->secmech.sdeschmacmd5) {
679 crypto_free_shash(server->secmech.hmacmd5);
680 server->secmech.hmacmd5 = NULL;
681 return -ENOMEM;
682 }
683 server->secmech.sdeschmacmd5->shash.tfm = server->secmech.hmacmd5;
684 server->secmech.sdeschmacmd5->shash.flags = 0x0;
685
686 return 0;
687}
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500688
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500689int
Steve French96daf2b2011-05-27 04:34:02 +0000690setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp)
Steve French9fbc5902010-08-20 20:42:26 +0000691{
Steve Frenchc8e56f12010-09-08 21:10:58 +0000692 int rc;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500693 int baselen;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500694 unsigned int tilen;
Tim Gardner2c957dd2013-11-07 16:40:57 -0700695 struct ntlmv2_resp *ntlmv2;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500696 char ntlmv2_hash[16];
697 unsigned char *tiblob = NULL; /* target info blob */
Peter Seiderer98ce94c2015-09-17 21:40:12 +0200698 __le64 rsp_timestamp;
Steve French6d027cf2006-06-05 16:26:05 +0000699
Jeff Layton3f618222013-06-12 19:52:14 -0500700 if (ses->server->negflavor == CIFS_NEGFLAVOR_EXTENDED) {
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500701 if (!ses->domainName) {
Germano Percossi39566442016-12-15 12:31:18 +0530702 if (ses->domainAuto) {
703 rc = find_domain_name(ses, nls_cp);
704 if (rc) {
705 cifs_dbg(VFS, "error %d finding domain name\n",
706 rc);
707 goto setup_ntlmv2_rsp_ret;
708 }
709 } else {
710 ses->domainName = kstrdup("", GFP_KERNEL);
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500711 }
712 }
713 } else {
Shirish Pargaonkar9daa42e2010-10-10 13:21:05 -0500714 rc = build_avpair_blob(ses, nls_cp);
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500715 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500716 cifs_dbg(VFS, "error %d building av pair blob\n", rc);
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500717 goto setup_ntlmv2_rsp_ret;
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500718 }
719 }
Steve Frencha8ee0342006-06-05 23:34:19 +0000720
Peter Seiderer98ce94c2015-09-17 21:40:12 +0200721 /* Must be within 5 minutes of the server (or in range +/-2h
722 * in case of Mac OS X), so simply carry over server timestamp
723 * (as Windows 7 does)
724 */
725 rsp_timestamp = find_timestamp(ses);
726
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500727 baselen = CIFS_SESS_KEY_SIZE + sizeof(struct ntlmv2_resp);
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500728 tilen = ses->auth_key.len;
729 tiblob = ses->auth_key.response;
730
731 ses->auth_key.response = kmalloc(baselen + tilen, GFP_KERNEL);
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500732 if (!ses->auth_key.response) {
Anton Protopopov4b550af2016-02-10 12:50:21 -0500733 rc = -ENOMEM;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500734 ses->auth_key.len = 0;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500735 goto setup_ntlmv2_rsp_ret;
736 }
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500737 ses->auth_key.len += baselen;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500738
Tim Gardner2c957dd2013-11-07 16:40:57 -0700739 ntlmv2 = (struct ntlmv2_resp *)
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500740 (ses->auth_key.response + CIFS_SESS_KEY_SIZE);
Tim Gardner2c957dd2013-11-07 16:40:57 -0700741 ntlmv2->blob_signature = cpu_to_le32(0x00000101);
742 ntlmv2->reserved = 0;
Peter Seiderer98ce94c2015-09-17 21:40:12 +0200743 ntlmv2->time = rsp_timestamp;
744
Tim Gardner2c957dd2013-11-07 16:40:57 -0700745 get_random_bytes(&ntlmv2->client_chal, sizeof(ntlmv2->client_chal));
746 ntlmv2->reserved2 = 0;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500747
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500748 memcpy(ses->auth_key.response + baselen, tiblob, tilen);
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500749
Rabin Vincentbd975d12016-07-19 09:26:21 +0200750 mutex_lock(&ses->server->srv_mutex);
751
Steve French95dc8dd2013-07-04 10:35:21 -0500752 rc = crypto_hmacmd5_alloc(ses->server);
753 if (rc) {
754 cifs_dbg(VFS, "could not crypto alloc hmacmd5 rc %d\n", rc);
Rabin Vincentbd975d12016-07-19 09:26:21 +0200755 goto unlock;
Steve French95dc8dd2013-07-04 10:35:21 -0500756 }
757
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -0500758 /* calculate ntlmv2_hash */
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500759 rc = calc_ntlmv2_hash(ses, ntlmv2_hash, nls_cp);
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500760 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500761 cifs_dbg(VFS, "could not get v2 hash rc %d\n", rc);
Rabin Vincentbd975d12016-07-19 09:26:21 +0200762 goto unlock;
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500763 }
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -0500764
765 /* calculate first part of the client response (CR1) */
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500766 rc = CalcNTLMv2_response(ses, ntlmv2_hash);
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500767 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500768 cifs_dbg(VFS, "Could not calculate CR1 rc: %d\n", rc);
Rabin Vincentbd975d12016-07-19 09:26:21 +0200769 goto unlock;
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500770 }
Steve Frenchb609f062007-07-09 07:55:14 +0000771
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500772 /* now calculate the session key for NTLMv2 */
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500773 rc = crypto_shash_setkey(ses->server->secmech.hmacmd5,
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500774 ntlmv2_hash, CIFS_HMAC_MD5_HASH_SIZE);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500775 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500776 cifs_dbg(VFS, "%s: Could not set NTLMV2 Hash as a key\n",
777 __func__);
Rabin Vincentbd975d12016-07-19 09:26:21 +0200778 goto unlock;
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500779 }
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500780
781 rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);
782 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500783 cifs_dbg(VFS, "%s: Could not init hmacmd5\n", __func__);
Rabin Vincentbd975d12016-07-19 09:26:21 +0200784 goto unlock;
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500785 }
786
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500787 rc = crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
Tim Gardner2c957dd2013-11-07 16:40:57 -0700788 ntlmv2->ntlmv2_hash,
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500789 CIFS_HMAC_MD5_HASH_SIZE);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500790 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500791 cifs_dbg(VFS, "%s: Could not update with response\n", __func__);
Rabin Vincentbd975d12016-07-19 09:26:21 +0200792 goto unlock;
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500793 }
Shirish Pargaonkar307fbd32010-10-21 14:25:17 -0500794
795 rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,
796 ses->auth_key.response);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500797 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500798 cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500799
Rabin Vincentbd975d12016-07-19 09:26:21 +0200800unlock:
801 mutex_unlock(&ses->server->srv_mutex);
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500802setup_ntlmv2_rsp_ret:
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500803 kfree(tiblob);
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500804
805 return rc;
Steve French6d027cf2006-06-05 16:26:05 +0000806}
807
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500808int
Steve French96daf2b2011-05-27 04:34:02 +0000809calc_seckey(struct cifs_ses *ses)
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500810{
811 int rc;
Herbert Xu9651ddb2016-01-24 21:17:17 +0800812 struct crypto_skcipher *tfm_arc4;
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500813 struct scatterlist sgin, sgout;
Herbert Xu9651ddb2016-01-24 21:17:17 +0800814 struct skcipher_request *req;
Sachin Prabhu5f4b5562016-10-17 16:40:22 -0400815 unsigned char *sec_key;
816
817 sec_key = kmalloc(CIFS_SESS_KEY_SIZE, GFP_KERNEL);
818 if (sec_key == NULL)
819 return -ENOMEM;
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500820
821 get_random_bytes(sec_key, CIFS_SESS_KEY_SIZE);
822
Herbert Xu9651ddb2016-01-24 21:17:17 +0800823 tfm_arc4 = crypto_alloc_skcipher("ecb(arc4)", 0, CRYPTO_ALG_ASYNC);
Shirish Pargaonkar7a8587e2011-01-29 13:54:58 -0600824 if (IS_ERR(tfm_arc4)) {
825 rc = PTR_ERR(tfm_arc4);
Joe Perchesf96637b2013-05-04 22:12:25 -0500826 cifs_dbg(VFS, "could not allocate crypto API arc4\n");
Sachin Prabhu5f4b5562016-10-17 16:40:22 -0400827 goto out;
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500828 }
829
Herbert Xu9651ddb2016-01-24 21:17:17 +0800830 rc = crypto_skcipher_setkey(tfm_arc4, ses->auth_key.response,
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500831 CIFS_SESS_KEY_SIZE);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500832 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500833 cifs_dbg(VFS, "%s: Could not set response as a key\n",
834 __func__);
Herbert Xu9651ddb2016-01-24 21:17:17 +0800835 goto out_free_cipher;
836 }
837
838 req = skcipher_request_alloc(tfm_arc4, GFP_KERNEL);
839 if (!req) {
840 rc = -ENOMEM;
841 cifs_dbg(VFS, "could not allocate crypto API arc4 request\n");
842 goto out_free_cipher;
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500843 }
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500844
845 sg_init_one(&sgin, sec_key, CIFS_SESS_KEY_SIZE);
Shirish Pargaonkard3686d52010-10-28 09:53:07 -0500846 sg_init_one(&sgout, ses->ntlmssp->ciphertext, CIFS_CPHTXT_SIZE);
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500847
Herbert Xu9651ddb2016-01-24 21:17:17 +0800848 skcipher_request_set_callback(req, 0, NULL, NULL);
849 skcipher_request_set_crypt(req, &sgin, &sgout, CIFS_CPHTXT_SIZE, NULL);
850
851 rc = crypto_skcipher_encrypt(req);
852 skcipher_request_free(req);
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500853 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500854 cifs_dbg(VFS, "could not encrypt session key rc: %d\n", rc);
Herbert Xu9651ddb2016-01-24 21:17:17 +0800855 goto out_free_cipher;
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500856 }
857
858 /* make secondary_key/nonce as session key */
859 memcpy(ses->auth_key.response, sec_key, CIFS_SESS_KEY_SIZE);
860 /* and make len as that of session key only */
861 ses->auth_key.len = CIFS_SESS_KEY_SIZE;
862
Herbert Xu9651ddb2016-01-24 21:17:17 +0800863out_free_cipher:
864 crypto_free_skcipher(tfm_arc4);
Sachin Prabhu5f4b5562016-10-17 16:40:22 -0400865out:
866 kfree(sec_key);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -0500867 return rc;
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500868}
869
870void
871cifs_crypto_shash_release(struct TCP_Server_Info *server)
872{
Steve French95dc8dd2013-07-04 10:35:21 -0500873 if (server->secmech.cmacaes) {
Steve French429b46f2013-06-26 23:45:05 -0500874 crypto_free_shash(server->secmech.cmacaes);
Steve French95dc8dd2013-07-04 10:35:21 -0500875 server->secmech.cmacaes = NULL;
876 }
Steve French429b46f2013-06-26 23:45:05 -0500877
Steve French95dc8dd2013-07-04 10:35:21 -0500878 if (server->secmech.hmacsha256) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700879 crypto_free_shash(server->secmech.hmacsha256);
Steve French95dc8dd2013-07-04 10:35:21 -0500880 server->secmech.hmacsha256 = NULL;
881 }
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700882
Steve French95dc8dd2013-07-04 10:35:21 -0500883 if (server->secmech.md5) {
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500884 crypto_free_shash(server->secmech.md5);
Steve French95dc8dd2013-07-04 10:35:21 -0500885 server->secmech.md5 = NULL;
886 }
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500887
Steve French95dc8dd2013-07-04 10:35:21 -0500888 if (server->secmech.hmacmd5) {
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500889 crypto_free_shash(server->secmech.hmacmd5);
Steve French95dc8dd2013-07-04 10:35:21 -0500890 server->secmech.hmacmd5 = NULL;
891 }
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500892
Steve French429b46f2013-06-26 23:45:05 -0500893 kfree(server->secmech.sdesccmacaes);
Steve French95dc8dd2013-07-04 10:35:21 -0500894 server->secmech.sdesccmacaes = NULL;
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700895 kfree(server->secmech.sdeschmacsha256);
Steve French95dc8dd2013-07-04 10:35:21 -0500896 server->secmech.sdeschmacsha256 = NULL;
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500897 kfree(server->secmech.sdeschmacmd5);
Steve French95dc8dd2013-07-04 10:35:21 -0500898 server->secmech.sdeschmacmd5 = NULL;
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500899 kfree(server->secmech.sdescmd5);
Steve French95dc8dd2013-07-04 10:35:21 -0500900 server->secmech.sdescmd5 = NULL;
Shirish Pargaonkard2b91522010-10-21 14:25:08 -0500901}