libcli:auth: Use 'bool ok' in ntv2_owf_gen()
[bbaumbach/samba-autobuild/.git] / libcli / auth / smbencrypt.c
1 /*
2    Unix SMB/CIFS implementation.
3    SMB parameters and setup
4    Copyright (C) Andrew Tridgell 1992-1998
5    Modified by Jeremy Allison 1995.
6    Copyright (C) Jeremy Allison 1995-2000.
7    Copyright (C) Luke Kennethc Casson Leighton 1996-2000.
8    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2002-2003
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14
15    This program 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 the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "includes.h"
25 #include "system/time.h"
26 #include "../libcli/auth/msrpc_parse.h"
27 #include "../lib/crypto/crypto.h"
28 #include "../libcli/auth/libcli_auth.h"
29 #include "../librpc/gen_ndr/ndr_ntlmssp.h"
30
31 #include <gnutls/gnutls.h>
32 #include <gnutls/crypto.h>
33
34 void SMBencrypt_hash(const uint8_t lm_hash[16], const uint8_t *c8, uint8_t p24[24])
35 {
36         uint8_t p21[21];
37
38         memset(p21,'\0',21);
39         memcpy(p21, lm_hash, 16);
40
41         SMBOWFencrypt(p21, c8, p24);
42
43 #ifdef DEBUG_PASSWORD
44         DEBUG(100,("SMBencrypt_hash: lm#, challenge, response\n"));
45         dump_data(100, p21, 16);
46         dump_data(100, c8, 8);
47         dump_data(100, p24, 24);
48 #endif
49 }
50
51 /*
52    This implements the X/Open SMB password encryption
53    It takes a password ('unix' string), a 8 byte "crypt key"
54    and puts 24 bytes of encrypted password into p24
55
56    Returns False if password must have been truncated to create LM hash
57 */
58
59 bool SMBencrypt(const char *passwd, const uint8_t *c8, uint8_t p24[24])
60 {
61         bool ret;
62         uint8_t lm_hash[16];
63
64         ret = E_deshash(passwd, lm_hash);
65         SMBencrypt_hash(lm_hash, c8, p24);
66         return ret;
67 }
68
69 /**
70  * Creates the MD4 Hash of the users password in NT UNICODE.
71  * @param passwd password in 'unix' charset.
72  * @param p16 return password hashed with md4, caller allocated 16 byte buffer
73  */
74
75 bool E_md4hash(const char *passwd, uint8_t p16[16])
76 {
77         size_t len;
78         smb_ucs2_t *wpwd;
79         bool ret;
80
81         ret = push_ucs2_talloc(NULL, &wpwd, passwd, &len);
82         if (!ret || len < 2) {
83                 /* We don't want to return fixed data, as most callers
84                  * don't check */
85                 mdfour(p16, (const uint8_t *)passwd, strlen(passwd));
86                 return false;
87         }
88
89         len -= 2;
90         mdfour(p16, (const uint8_t *)wpwd, len);
91
92         talloc_free(wpwd);
93         return true;
94 }
95
96 /**
97  * Creates the MD5 Hash of a combination of 16 byte salt and 16 byte NT hash.
98  * @param 16 byte salt.
99  * @param 16 byte NT hash.
100  * @param 16 byte return hashed with md5, caller allocated 16 byte buffer
101  */
102
103 void E_md5hash(const uint8_t salt[16], const uint8_t nthash[16], uint8_t hash_out[16])
104 {
105         gnutls_hash_hd_t hash_hnd = NULL;
106         int rc;
107
108         rc = gnutls_hash_init(&hash_hnd, GNUTLS_DIG_MD5);
109         if (rc < 0) {
110                 goto out;
111         }
112
113         rc = gnutls_hash(hash_hnd, salt, 16);
114         if (rc < 0) {
115                 gnutls_hash_deinit(hash_hnd, NULL);
116                 goto out;
117         }
118         rc = gnutls_hash(hash_hnd, nthash, 16);
119         if (rc < 0) {
120                 gnutls_hash_deinit(hash_hnd, NULL);
121                 goto out;
122         }
123         gnutls_hash_deinit(hash_hnd, hash_out);
124
125 out:
126         return;
127 }
128
129 /**
130  * Creates the DES forward-only Hash of the users password in DOS ASCII charset
131  * @param passwd password in 'unix' charset.
132  * @param p16 return password hashed with DES, caller allocated 16 byte buffer
133  * @return false if password was > 14 characters, and therefore may be incorrect, otherwise true
134  * @note p16 is filled in regardless
135  */
136
137 bool E_deshash(const char *passwd, uint8_t p16[16])
138 {
139         bool ret;
140         uint8_t dospwd[14];
141         TALLOC_CTX *frame = talloc_stackframe();
142
143         size_t converted_size;
144
145         char *tmpbuf;
146
147         ZERO_STRUCT(dospwd);
148
149         tmpbuf = strupper_talloc(frame, passwd);
150         if (tmpbuf == NULL) {
151                 /* Too many callers don't check this result, we need to fill in the buffer with something */
152                 strlcpy((char *)dospwd, passwd ? passwd : "", sizeof(dospwd));
153                 E_P16(dospwd, p16);
154                 talloc_free(frame);
155                 return false;
156         }
157
158         ZERO_STRUCT(dospwd);
159
160         ret = convert_string_error(CH_UNIX, CH_DOS, tmpbuf, strlen(tmpbuf), dospwd, sizeof(dospwd), &converted_size);
161         talloc_free(frame);
162
163         /* Only the first 14 chars are considered, password need not
164          * be null terminated.  We do this in the error and success
165          * case to avoid returning a fixed 'password' buffer, but
166          * callers should not use it when E_deshash returns false */
167
168         E_P16((const uint8_t *)dospwd, p16);
169
170         ZERO_STRUCT(dospwd);
171
172         return ret;
173 }
174
175 /**
176  * Creates the MD4 and DES (LM) Hash of the users password.
177  * MD4 is of the NT Unicode, DES is of the DOS UPPERCASE password.
178  * @param passwd password in 'unix' charset.
179  * @param nt_p16 return password hashed with md4, caller allocated 16 byte buffer
180  * @param p16 return password hashed with des, caller allocated 16 byte buffer
181  */
182
183 /* Does both the NT and LM owfs of a user's password */
184 void nt_lm_owf_gen(const char *pwd, uint8_t nt_p16[16], uint8_t p16[16])
185 {
186         /* Calculate the MD4 hash (NT compatible) of the password */
187         memset(nt_p16, '\0', 16);
188         E_md4hash(pwd, nt_p16);
189
190 #ifdef DEBUG_PASSWORD
191         DEBUG(100,("nt_lm_owf_gen: pwd, nt#\n"));
192         dump_data(120, (const uint8_t *)pwd, strlen(pwd));
193         dump_data(100, nt_p16, 16);
194 #endif
195
196         E_deshash(pwd, (uint8_t *)p16);
197
198 #ifdef DEBUG_PASSWORD
199         DEBUG(100,("nt_lm_owf_gen: pwd, lm#\n"));
200         dump_data(120, (const uint8_t *)pwd, strlen(pwd));
201         dump_data(100, p16, 16);
202 #endif
203 }
204
205 /* Does both the NTLMv2 owfs of a user's password */
206 bool ntv2_owf_gen(const uint8_t owf[16],
207                   const char *user_in, const char *domain_in,
208                   uint8_t kr_buf[16])
209 {
210         smb_ucs2_t *user;
211         smb_ucs2_t *domain;
212         size_t user_byte_len;
213         size_t domain_byte_len;
214         gnutls_hmac_hd_t hmac_hnd = NULL;
215         int rc;
216         bool ok = false;
217         TALLOC_CTX *mem_ctx = talloc_init("ntv2_owf_gen for %s\\%s", domain_in, user_in);
218
219         if (!mem_ctx) {
220                 return false;
221         }
222
223         if (!user_in) {
224                 user_in = "";
225         }
226
227         if (!domain_in) {
228                 domain_in = "";
229         }
230
231         user_in = strupper_talloc(mem_ctx, user_in);
232         if (user_in == NULL) {
233                 talloc_free(mem_ctx);
234                 return false;
235         }
236
237         ok = push_ucs2_talloc(mem_ctx, &user, user_in, &user_byte_len );
238         if (!ok) {
239                 DEBUG(0, ("push_uss2_talloc() for user failed)\n"));
240                 talloc_free(mem_ctx);
241                 return false;
242         }
243
244         ok = push_ucs2_talloc(mem_ctx, &domain, domain_in, &domain_byte_len);
245         if (!ok) {
246                 DEBUG(0, ("push_ucs2_talloc() for domain failed\n"));
247                 talloc_free(mem_ctx);
248                 return false;
249         }
250
251         SMB_ASSERT(user_byte_len >= 2);
252         SMB_ASSERT(domain_byte_len >= 2);
253
254         /* We don't want null termination */
255         user_byte_len = user_byte_len - 2;
256         domain_byte_len = domain_byte_len - 2;
257
258         rc = gnutls_hmac_init(&hmac_hnd,
259                               GNUTLS_MAC_MD5,
260                               owf,
261                               16);
262         if (rc < 0) {
263                 ok = false;
264                 goto out;
265         }
266
267         rc = gnutls_hmac(hmac_hnd, user, user_byte_len);
268         if (rc < 0) {
269                 gnutls_hmac_deinit(hmac_hnd, NULL);
270                 ok = false;
271                 goto out;
272         }
273         rc = gnutls_hmac(hmac_hnd, domain, domain_byte_len);
274         if (rc < 0) {
275                 gnutls_hmac_deinit(hmac_hnd, NULL);
276                 ok = false;
277                 goto out;
278         }
279
280         gnutls_hmac_deinit(hmac_hnd, kr_buf);
281
282 #ifdef DEBUG_PASSWORD
283         DEBUG(100, ("ntv2_owf_gen: user, domain, owfkey, kr\n"));
284         dump_data(100, (uint8_t *)user, user_byte_len);
285         dump_data(100, (uint8_t *)domain, domain_byte_len);
286         dump_data(100, owf, 16);
287         dump_data(100, kr_buf, 16);
288 #endif
289
290         ok = true;
291 out:
292         talloc_free(mem_ctx);
293         return ok;
294 }
295
296 /* Does the des encryption from the NT or LM MD4 hash. */
297 void SMBOWFencrypt(const uint8_t passwd[16], const uint8_t *c8, uint8_t p24[24])
298 {
299         uint8_t p21[21];
300
301         ZERO_STRUCT(p21);
302
303         memcpy(p21, passwd, 16);
304         E_P24(p21, c8, p24);
305 }
306
307 /* Does the des encryption. */
308
309 void SMBNTencrypt_hash(const uint8_t nt_hash[16], const uint8_t *c8, uint8_t *p24)
310 {
311         uint8_t p21[21];
312
313         memset(p21,'\0',21);
314         memcpy(p21, nt_hash, 16);
315         SMBOWFencrypt(p21, c8, p24);
316
317 #ifdef DEBUG_PASSWORD
318         DEBUG(100,("SMBNTencrypt: nt#, challenge, response\n"));
319         dump_data(100, p21, 16);
320         dump_data(100, c8, 8);
321         dump_data(100, p24, 24);
322 #endif
323 }
324
325 /* Does the NT MD4 hash then des encryption. Plaintext version of the above. */
326
327 void SMBNTencrypt(const char *passwd, const uint8_t *c8, uint8_t *p24)
328 {
329         uint8_t nt_hash[16];
330         E_md4hash(passwd, nt_hash);
331         SMBNTencrypt_hash(nt_hash, c8, p24);
332 }
333
334
335 /* Does the md5 encryption from the Key Response for NTLMv2. */
336 void SMBOWFencrypt_ntv2(const uint8_t kr[16],
337                         const DATA_BLOB *srv_chal,
338                         const DATA_BLOB *smbcli_chal,
339                         uint8_t resp_buf[16])
340 {
341         gnutls_hmac_hd_t hmac_hnd = NULL;
342         int rc;
343
344         rc = gnutls_hmac_init(&hmac_hnd,
345                               GNUTLS_MAC_MD5,
346                               kr,
347                               16);
348         if (rc < 0) {
349                 return;
350         }
351
352         rc = gnutls_hmac(hmac_hnd, srv_chal->data, srv_chal->length);
353         if (rc < 0) {
354                 return;
355         }
356         rc = gnutls_hmac(hmac_hnd, smbcli_chal->data, smbcli_chal->length);
357         if (rc < 0) {
358                 gnutls_hmac_deinit(hmac_hnd, NULL);
359                 return;
360         }
361
362         gnutls_hmac_deinit(hmac_hnd, resp_buf);
363
364 #ifdef DEBUG_PASSWORD
365         DEBUG(100, ("SMBOWFencrypt_ntv2: srv_chal, smbcli_chal, resp_buf\n"));
366         dump_data(100, srv_chal->data, srv_chal->length);
367         dump_data(100, smbcli_chal->data, smbcli_chal->length);
368         dump_data(100, resp_buf, 16);
369 #endif
370 }
371
372 void SMBsesskeygen_ntv2(const uint8_t kr[16],
373                         const uint8_t * nt_resp, uint8_t sess_key[16])
374 {
375         /* a very nice, 128 bit, variable session key */
376         gnutls_hmac_fast(GNUTLS_MAC_MD5,
377                          kr,
378                          16,
379                          nt_resp,
380                          16,
381                          sess_key);
382
383 #ifdef DEBUG_PASSWORD
384         DEBUG(100, ("SMBsesskeygen_ntv2:\n"));
385         dump_data(100, sess_key, 16);
386 #endif
387 }
388
389 void SMBsesskeygen_ntv1(const uint8_t kr[16], uint8_t sess_key[16])
390 {
391         /* yes, this session key does not change - yes, this
392            is a problem - but it is 128 bits */
393
394         mdfour((uint8_t *)sess_key, kr, 16);
395
396 #ifdef DEBUG_PASSWORD
397         DEBUG(100, ("SMBsesskeygen_ntv1:\n"));
398         dump_data(100, sess_key, 16);
399 #endif
400 }
401
402 void SMBsesskeygen_lm_sess_key(const uint8_t lm_hash[16],
403                                const uint8_t lm_resp[24], /* only uses 8 */
404                                uint8_t sess_key[16])
405 {
406         /* Calculate the LM session key (effective length 40 bits,
407            but changes with each session) */
408         uint8_t p24[24];
409         uint8_t partial_lm_hash[14];
410
411         memcpy(partial_lm_hash, lm_hash, 8);
412         memset(partial_lm_hash + 8, 0xbd, 6);
413
414         des_crypt56(p24,   lm_resp, partial_lm_hash,     1);
415         des_crypt56(p24+8, lm_resp, partial_lm_hash + 7, 1);
416
417         memcpy(sess_key, p24, 16);
418
419 #ifdef DEBUG_PASSWORD
420         DEBUG(100, ("SMBsesskeygen_lm_sess_key: \n"));
421         dump_data(100, sess_key, 16);
422 #endif
423 }
424
425 DATA_BLOB NTLMv2_generate_names_blob(TALLOC_CTX *mem_ctx,
426                                      const char *hostname,
427                                      const char *domain)
428 {
429         DATA_BLOB names_blob = data_blob_talloc(mem_ctx, NULL, 0);
430
431         /* Deliberately ignore return here.. */
432         if (hostname != NULL) {
433                 (void)msrpc_gen(mem_ctx, &names_blob,
434                           "aaa",
435                           MsvAvNbDomainName, domain,
436                           MsvAvNbComputerName, hostname,
437                           MsvAvEOL, "");
438         } else {
439                 (void)msrpc_gen(mem_ctx, &names_blob,
440                           "aa",
441                           MsvAvNbDomainName, domain,
442                           MsvAvEOL, "");
443         }
444         return names_blob;
445 }
446
447 static DATA_BLOB NTLMv2_generate_client_data(TALLOC_CTX *mem_ctx,
448                                              NTTIME nttime,
449                                              const DATA_BLOB *names_blob)
450 {
451         uint8_t client_chal[8];
452         DATA_BLOB response = data_blob(NULL, 0);
453         uint8_t long_date[8];
454
455         generate_random_buffer(client_chal, sizeof(client_chal));
456
457         push_nttime(long_date, 0, nttime);
458
459         /* See http://www.ubiqx.org/cifs/SMB.html#SMB.8.5 */
460
461         /* Deliberately ignore return here.. */
462         (void)msrpc_gen(mem_ctx, &response, "ddbbdb",
463                   0x00000101,     /* Header  */
464                   0,              /* 'Reserved'  */
465                   long_date, 8,   /* Timestamp */
466                   client_chal, 8, /* client challenge */
467                   0,              /* Unknown */
468                   names_blob->data, names_blob->length);        /* End of name list */
469
470         return response;
471 }
472
473 static DATA_BLOB NTLMv2_generate_response(TALLOC_CTX *out_mem_ctx,
474                                           const uint8_t ntlm_v2_hash[16],
475                                           const DATA_BLOB *server_chal,
476                                           NTTIME nttime,
477                                           const DATA_BLOB *names_blob)
478 {
479         uint8_t ntlmv2_response[16];
480         DATA_BLOB ntlmv2_client_data;
481         DATA_BLOB final_response;
482
483         TALLOC_CTX *mem_ctx = talloc_named(out_mem_ctx, 0,
484                                            "NTLMv2_generate_response internal context");
485
486         if (!mem_ctx) {
487                 return data_blob(NULL, 0);
488         }
489
490         /* NTLMv2 */
491         /* generate some data to pass into the response function - including
492            the hostname and domain name of the server */
493         ntlmv2_client_data = NTLMv2_generate_client_data(mem_ctx, nttime, names_blob);
494
495         /* Given that data, and the challenge from the server, generate a response */
496         SMBOWFencrypt_ntv2(ntlm_v2_hash, server_chal, &ntlmv2_client_data, ntlmv2_response);
497
498         final_response = data_blob_talloc(out_mem_ctx, NULL, sizeof(ntlmv2_response) + ntlmv2_client_data.length);
499
500         memcpy(final_response.data, ntlmv2_response, sizeof(ntlmv2_response));
501
502         memcpy(final_response.data+sizeof(ntlmv2_response),
503                ntlmv2_client_data.data, ntlmv2_client_data.length);
504
505         talloc_free(mem_ctx);
506
507         return final_response;
508 }
509
510 static DATA_BLOB LMv2_generate_response(TALLOC_CTX *mem_ctx,
511                                         const uint8_t ntlm_v2_hash[16],
512                                         const DATA_BLOB *server_chal)
513 {
514         uint8_t lmv2_response[16];
515         DATA_BLOB lmv2_client_data = data_blob_talloc(mem_ctx, NULL, 8);
516         DATA_BLOB final_response = data_blob_talloc(mem_ctx, NULL,24);
517
518         /* LMv2 */
519         /* client-supplied random data */
520         generate_random_buffer(lmv2_client_data.data, lmv2_client_data.length);
521
522         /* Given that data, and the challenge from the server, generate a response */
523         SMBOWFencrypt_ntv2(ntlm_v2_hash, server_chal, &lmv2_client_data, lmv2_response);
524         memcpy(final_response.data, lmv2_response, sizeof(lmv2_response));
525
526         /* after the first 16 bytes is the random data we generated above,
527            so the server can verify us with it */
528         memcpy(final_response.data+sizeof(lmv2_response),
529                lmv2_client_data.data, lmv2_client_data.length);
530
531         data_blob_free(&lmv2_client_data);
532
533         return final_response;
534 }
535
536 bool SMBNTLMv2encrypt_hash(TALLOC_CTX *mem_ctx,
537                            const char *user, const char *domain, const uint8_t nt_hash[16],
538                            const DATA_BLOB *server_chal,
539                            const NTTIME *server_timestamp,
540                            const DATA_BLOB *names_blob,
541                            DATA_BLOB *lm_response, DATA_BLOB *nt_response,
542                            DATA_BLOB *lm_session_key, DATA_BLOB *user_session_key)
543 {
544         uint8_t ntlm_v2_hash[16];
545
546         /* We don't use the NT# directly.  Instead we use it mashed up with
547            the username and domain.
548            This prevents username swapping during the auth exchange
549         */
550         if (!ntv2_owf_gen(nt_hash, user, domain, ntlm_v2_hash)) {
551                 return false;
552         }
553
554         if (nt_response) {
555                 const NTTIME *nttime = server_timestamp;
556                 NTTIME _now = 0;
557
558                 if (nttime == NULL) {
559                         struct timeval tv_now = timeval_current();
560                         _now = timeval_to_nttime(&tv_now);
561                         nttime = &_now;
562                 }
563
564                 *nt_response = NTLMv2_generate_response(mem_ctx,
565                                                         ntlm_v2_hash,
566                                                         server_chal,
567                                                         *nttime,
568                                                         names_blob);
569                 if (user_session_key) {
570                         *user_session_key = data_blob_talloc(mem_ctx, NULL, 16);
571
572                         /* The NTLMv2 calculations also provide a session key, for signing etc later */
573                         /* use only the first 16 bytes of nt_response for session key */
574                         SMBsesskeygen_ntv2(ntlm_v2_hash, nt_response->data, user_session_key->data);
575                 }
576         }
577
578         /* LMv2 */
579
580         if (lm_response) {
581                 if (server_timestamp != NULL) {
582                         *lm_response = data_blob_talloc_zero(mem_ctx, 24);
583                 } else {
584                         *lm_response = LMv2_generate_response(mem_ctx,
585                                                               ntlm_v2_hash,
586                                                               server_chal);
587                 }
588                 if (lm_session_key) {
589                         *lm_session_key = data_blob_talloc(mem_ctx, NULL, 16);
590
591                         /* The NTLMv2 calculations also provide a session key, for signing etc later */
592                         /* use only the first 16 bytes of lm_response for session key */
593                         SMBsesskeygen_ntv2(ntlm_v2_hash, lm_response->data, lm_session_key->data);
594                 }
595         }
596
597         return true;
598 }
599
600 bool SMBNTLMv2encrypt(TALLOC_CTX *mem_ctx,
601                       const char *user, const char *domain,
602                       const char *password,
603                       const DATA_BLOB *server_chal,
604                       const DATA_BLOB *names_blob,
605                       DATA_BLOB *lm_response, DATA_BLOB *nt_response,
606                       DATA_BLOB *lm_session_key, DATA_BLOB *user_session_key)
607 {
608         uint8_t nt_hash[16];
609         E_md4hash(password, nt_hash);
610
611         return SMBNTLMv2encrypt_hash(mem_ctx,
612                                      user, domain, nt_hash,
613                                      server_chal, NULL, names_blob,
614                                      lm_response, nt_response, lm_session_key, user_session_key);
615 }
616
617 NTSTATUS NTLMv2_RESPONSE_verify_netlogon_creds(const char *account_name,
618                         const char *account_domain,
619                         const DATA_BLOB response,
620                         const struct netlogon_creds_CredentialState *creds,
621                         const char *workgroup)
622 {
623         TALLOC_CTX *frame = NULL;
624         /* RespType + HiRespType */
625         static const char *magic = "\x01\x01";
626         int cmp;
627         struct NTLMv2_RESPONSE v2_resp;
628         enum ndr_err_code err;
629         const struct AV_PAIR *av_nb_cn = NULL;
630         const struct AV_PAIR *av_nb_dn = NULL;
631
632         if (response.length < 48) {
633                 /*
634                  * NTLMv2_RESPONSE has at least 48 bytes.
635                  */
636                 return NT_STATUS_OK;
637         }
638
639         cmp = memcmp(response.data + 16, magic, 2);
640         if (cmp != 0) {
641                 /*
642                  * It doesn't look like a valid NTLMv2_RESPONSE
643                  */
644                 return NT_STATUS_OK;
645         }
646
647         frame = talloc_stackframe();
648
649         err = ndr_pull_struct_blob(&response, frame, &v2_resp,
650                 (ndr_pull_flags_fn_t)ndr_pull_NTLMv2_RESPONSE);
651         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
652                 NTSTATUS status;
653                 status = ndr_map_error2ntstatus(err);
654                 DEBUG(2,("Failed to parse NTLMv2_RESPONSE "
655                          "length %u - %s - %s\n",
656                          (unsigned)response.length,
657                          ndr_map_error2string(err),
658                          nt_errstr(status)));
659                 dump_data(2, response.data, response.length);
660                 TALLOC_FREE(frame);
661                 return status;
662         }
663
664         if (DEBUGLVL(10)) {
665                 NDR_PRINT_DEBUG(NTLMv2_RESPONSE, &v2_resp);
666         }
667
668         /*
669          * Make sure the netbios computer name in the
670          * NTLMv2_RESPONSE matches the computer name
671          * in the secure channel credentials for workstation
672          * trusts.
673          *
674          * And the netbios domain name matches our
675          * workgroup.
676          *
677          * This prevents workstations from requesting
678          * the session key of NTLMSSP sessions of clients
679          * to other hosts.
680          */
681         if (creds->secure_channel_type == SEC_CHAN_WKSTA) {
682                 av_nb_cn = ndr_ntlmssp_find_av(&v2_resp.Challenge.AvPairs,
683                                                MsvAvNbComputerName);
684                 av_nb_dn = ndr_ntlmssp_find_av(&v2_resp.Challenge.AvPairs,
685                                                MsvAvNbDomainName);
686         }
687
688         if (av_nb_cn != NULL) {
689                 const char *v = NULL;
690                 char *a = NULL;
691                 size_t len;
692
693                 v = av_nb_cn->Value.AvNbComputerName;
694
695                 a = talloc_strdup(frame, creds->account_name);
696                 if (a == NULL) {
697                         TALLOC_FREE(frame);
698                         return NT_STATUS_NO_MEMORY;
699                 }
700                 len = strlen(a);
701                 if (len > 0 && a[len - 1] == '$') {
702                         a[len - 1] = '\0';
703                 }
704
705                 cmp = strcasecmp_m(a, v);
706                 if (cmp != 0) {
707                         DEBUG(2,("%s: NTLMv2_RESPONSE with "
708                                  "NbComputerName[%s] rejected "
709                                  "for user[%s\\%s] "
710                                  "against SEC_CHAN_WKSTA[%s/%s] "
711                                  "in workgroup[%s]\n",
712                                  __func__, v,
713                                  account_domain,
714                                  account_name,
715                                  creds->computer_name,
716                                  creds->account_name,
717                                  workgroup));
718                         TALLOC_FREE(frame);
719                         return NT_STATUS_LOGON_FAILURE;
720                 }
721         }
722         if (av_nb_dn != NULL) {
723                 const char *v = NULL;
724
725                 v = av_nb_dn->Value.AvNbDomainName;
726
727                 cmp = strcasecmp_m(workgroup, v);
728                 if (cmp != 0) {
729                         DEBUG(2,("%s: NTLMv2_RESPONSE with "
730                                  "NbDomainName[%s] rejected "
731                                  "for user[%s\\%s] "
732                                  "against SEC_CHAN_WKSTA[%s/%s] "
733                                  "in workgroup[%s]\n",
734                                  __func__, v,
735                                  account_domain,
736                                  account_name,
737                                  creds->computer_name,
738                                  creds->account_name,
739                                  workgroup));
740                         TALLOC_FREE(frame);
741                         return NT_STATUS_LOGON_FAILURE;
742                 }
743         }
744
745         TALLOC_FREE(frame);
746         return NT_STATUS_OK;
747 }
748
749 /***********************************************************
750  encode a password buffer with a unicode password.  The buffer
751  is filled with random data to make it harder to attack.
752 ************************************************************/
753 bool encode_pw_buffer(uint8_t buffer[516], const char *password, int string_flags)
754 {
755         uint8_t new_pw[512];
756         ssize_t new_pw_len;
757
758         /* the incoming buffer can be any alignment. */
759         string_flags |= STR_NOALIGN;
760
761         new_pw_len = push_string(new_pw,
762                                  password,
763                                  sizeof(new_pw), string_flags);
764         if (new_pw_len == -1) {
765                 return false;
766         }
767
768         memcpy(&buffer[512 - new_pw_len], new_pw, new_pw_len);
769
770         generate_random_buffer(buffer, 512 - new_pw_len);
771
772         /*
773          * The length of the new password is in the last 4 bytes of
774          * the data buffer.
775          */
776         SIVAL(buffer, 512, new_pw_len);
777         ZERO_STRUCT(new_pw);
778         return true;
779 }
780
781
782 /***********************************************************
783  decode a password buffer
784  *new_pw_len is the length in bytes of the possibly mulitbyte
785  returned password including termination.
786 ************************************************************/
787
788 bool decode_pw_buffer(TALLOC_CTX *ctx,
789                       uint8_t in_buffer[516],
790                       char **pp_new_pwrd,
791                       size_t *new_pw_len,
792                       charset_t string_charset)
793 {
794         int byte_len=0;
795
796         *pp_new_pwrd = NULL;
797         *new_pw_len = 0;
798
799         /*
800           Warning !!! : This function is called from some rpc call.
801           The password IN the buffer may be a UNICODE string.
802           The password IN new_pwrd is an ASCII string
803           If you reuse that code somewhere else check first.
804         */
805
806         /* The length of the new password is in the last 4 bytes of the data buffer. */
807
808         byte_len = IVAL(in_buffer, 512);
809
810 #ifdef DEBUG_PASSWORD
811         dump_data(100, in_buffer, 516);
812 #endif
813
814         /* Password cannot be longer than the size of the password buffer */
815         if ( (byte_len < 0) || (byte_len > 512)) {
816                 DEBUG(0, ("decode_pw_buffer: incorrect password length (%d).\n", byte_len));
817                 DEBUG(0, ("decode_pw_buffer: check that 'encrypt passwords = yes'\n"));
818                 return false;
819         }
820
821         /* decode into the return buffer. */
822         if (!convert_string_talloc(ctx, string_charset, CH_UNIX,
823                                    &in_buffer[512 - byte_len],
824                                    byte_len,
825                                    (void *)pp_new_pwrd,
826                                    new_pw_len)) {
827                 DEBUG(0, ("decode_pw_buffer: failed to convert incoming password\n"));
828                 return false;
829         }
830
831 #ifdef DEBUG_PASSWORD
832         DEBUG(100,("decode_pw_buffer: new_pwrd: "));
833         dump_data(100, (uint8_t *)*pp_new_pwrd, *new_pw_len);
834         DEBUG(100,("multibyte len:%lu\n", (unsigned long int)*new_pw_len));
835         DEBUG(100,("original char len:%d\n", byte_len/2));
836 #endif
837
838         return true;
839 }
840
841 /***********************************************************
842  Decode an arc4 encrypted password change buffer.
843 ************************************************************/
844
845 void encode_or_decode_arc4_passwd_buffer(unsigned char pw_buf[532], const DATA_BLOB *psession_key)
846 {
847         gnutls_hash_hd_t hash_hnd = NULL;
848         unsigned char key_out[16];
849         int rc;
850
851         /* Confounder is last 16 bytes. */
852
853         rc = gnutls_hash_init(&hash_hnd, GNUTLS_DIG_MD5);
854         if (rc < 0) {
855                 goto out;
856         }
857
858         rc = gnutls_hash(hash_hnd, &pw_buf[516], 16);
859         if (rc < 0) {
860                 gnutls_hash_deinit(hash_hnd, NULL);
861                 goto out;
862         }
863         rc = gnutls_hash(hash_hnd, psession_key->data, psession_key->length);
864         if (rc < 0) {
865                 gnutls_hash_deinit(hash_hnd, NULL);
866                 goto out;
867         }
868         gnutls_hash_deinit(hash_hnd, key_out);
869
870         /* arc4 with key_out. */
871         arcfour_crypt(pw_buf, key_out, 516);
872
873         ZERO_ARRAY(key_out);
874
875 out:
876         return;
877 }
878
879 /***********************************************************
880  encode a password buffer with an already unicode password.  The
881  rest of the buffer is filled with random data to make it harder to attack.
882 ************************************************************/
883 bool set_pw_in_buffer(uint8_t buffer[516], const DATA_BLOB *password)
884 {
885         if (password->length > 512) {
886                 return false;
887         }
888
889         memcpy(&buffer[512 - password->length], password->data, password->length);
890
891         generate_random_buffer(buffer, 512 - password->length);
892
893         /*
894          * The length of the new password is in the last 4 bytes of
895          * the data buffer.
896          */
897         SIVAL(buffer, 512, password->length);
898         return true;
899 }
900
901 /***********************************************************
902  decode a password buffer
903  *new_pw_size is the length in bytes of the extracted unicode password
904 ************************************************************/
905 bool extract_pw_from_buffer(TALLOC_CTX *mem_ctx,
906                             uint8_t in_buffer[516], DATA_BLOB *new_pass)
907 {
908         int byte_len=0;
909
910         /* The length of the new password is in the last 4 bytes of the data buffer. */
911
912         byte_len = IVAL(in_buffer, 512);
913
914 #ifdef DEBUG_PASSWORD
915         dump_data(100, in_buffer, 516);
916 #endif
917
918         /* Password cannot be longer than the size of the password buffer */
919         if ( (byte_len < 0) || (byte_len > 512)) {
920                 return false;
921         }
922
923         *new_pass = data_blob_talloc(mem_ctx, &in_buffer[512 - byte_len], byte_len);
924
925         if (!new_pass->data) {
926                 return false;
927         }
928
929         return true;
930 }
931
932
933 /* encode a wkssvc_PasswordBuffer:
934  *
935  * similar to samr_CryptPasswordEx. Different: 8byte confounder (instead of
936  * 16byte), confounder in front of the 516 byte buffer (instead of after that
937  * buffer), calling MD5Update() first with session_key and then with confounder
938  * (vice versa in samr) - Guenther */
939
940 void encode_wkssvc_join_password_buffer(TALLOC_CTX *mem_ctx,
941                                         const char *pwd,
942                                         DATA_BLOB *session_key,
943                                         struct wkssvc_PasswordBuffer **pwd_buf)
944 {
945         uint8_t buffer[516];
946         gnutls_hash_hd_t hash_hnd = NULL;
947         struct wkssvc_PasswordBuffer *my_pwd_buf = NULL;
948         DATA_BLOB confounded_session_key;
949         int confounder_len = 8;
950         uint8_t confounder[8];
951         int rc;
952
953         my_pwd_buf = talloc_zero(mem_ctx, struct wkssvc_PasswordBuffer);
954         if (!my_pwd_buf) {
955                 return;
956         }
957
958         confounded_session_key = data_blob_talloc(mem_ctx, NULL, 16);
959
960         encode_pw_buffer(buffer, pwd, STR_UNICODE);
961
962         generate_random_buffer((uint8_t *)confounder, confounder_len);
963
964         rc = gnutls_hash_init(&hash_hnd, GNUTLS_DIG_MD5);
965         if (rc < 0) {
966                 goto out;
967         }
968
969         rc = gnutls_hash(hash_hnd, session_key->data, session_key->length);
970         if (rc < 0) {
971                 gnutls_hash_deinit(hash_hnd, NULL);
972                 goto out;
973         }
974         rc = gnutls_hash(hash_hnd, confounder, confounder_len);
975         if (rc < 0) {
976                 gnutls_hash_deinit(hash_hnd, NULL);
977                 goto out;
978         }
979         gnutls_hash_deinit(hash_hnd, confounded_session_key.data);
980
981         arcfour_crypt_blob(buffer, 516, &confounded_session_key);
982
983         memcpy(&my_pwd_buf->data[0], confounder, confounder_len);
984         ZERO_ARRAY(confounder);
985         memcpy(&my_pwd_buf->data[8], buffer, 516);
986         ZERO_ARRAY(buffer);
987
988         data_blob_clear_free(&confounded_session_key);
989
990         *pwd_buf = my_pwd_buf;
991
992 out:
993         return;
994 }
995
996 WERROR decode_wkssvc_join_password_buffer(TALLOC_CTX *mem_ctx,
997                                           struct wkssvc_PasswordBuffer *pwd_buf,
998                                           DATA_BLOB *session_key,
999                                           char **pwd)
1000 {
1001         gnutls_hash_hd_t hash_hnd = NULL;
1002         uint8_t buffer[516];
1003         size_t pwd_len;
1004         WERROR result;
1005         bool ok;
1006         int rc;
1007
1008         DATA_BLOB confounded_session_key;
1009
1010         int confounder_len = 8;
1011         uint8_t confounder[8];
1012
1013         *pwd = NULL;
1014
1015         if (!pwd_buf) {
1016                 return WERR_INVALID_PASSWORD;
1017         }
1018
1019         if (session_key->length != 16) {
1020                 DEBUG(10,("invalid session key\n"));
1021                 return WERR_INVALID_PASSWORD;
1022         }
1023
1024         confounded_session_key = data_blob_talloc(mem_ctx, NULL, 16);
1025
1026         memcpy(&confounder, &pwd_buf->data[0], confounder_len);
1027         memcpy(&buffer, &pwd_buf->data[8], 516);
1028
1029         rc = gnutls_hash_init(&hash_hnd, GNUTLS_DIG_MD5);
1030         if (rc < 0) {
1031                 result = WERR_NOT_ENOUGH_MEMORY;
1032                 goto out;
1033         }
1034
1035         rc = gnutls_hash(hash_hnd, session_key->data, session_key->length);
1036         if (rc < 0) {
1037                 gnutls_hash_deinit(hash_hnd, NULL);
1038                 result = WERR_INTERNAL_ERROR;
1039                 goto out;
1040         }
1041         rc = gnutls_hash(hash_hnd, confounder, confounder_len);
1042         if (rc < 0) {
1043                 gnutls_hash_deinit(hash_hnd, NULL);
1044                 result = WERR_INTERNAL_ERROR;
1045                 goto out;
1046         }
1047         gnutls_hash_deinit(hash_hnd, confounded_session_key.data);
1048
1049         arcfour_crypt_blob(buffer, 516, &confounded_session_key);
1050
1051         ok = decode_pw_buffer(mem_ctx, buffer, pwd, &pwd_len, CH_UTF16);
1052
1053         ZERO_ARRAY(confounder);
1054         ZERO_ARRAY(buffer);
1055
1056         data_blob_clear_free(&confounded_session_key);
1057
1058         if (!ok) {
1059                 result = WERR_INVALID_PASSWORD;
1060                 goto out;
1061         }
1062
1063         result = WERR_OK;
1064 out:
1065         return result;
1066 }
1067