1 /*
2 * This file and its contents are supplied under the terms of the
3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 * You may only use this file in accordance with the terms of version
5 * 1.0 of the CDDL.
6 *
7 * A full copy of the text of the CDDL should have accompanied this
8 * source. A copy of the CDDL is also available via the Internet at
9 * http://www.illumos.org/license/CDDL.
10 */
11
12 /*
13 * Copyright 2017 Nexenta Systems, Inc. All rights reserved.
14 */
15
16 /*
17 * SPNEGO back-end for NTLMSSP. See [MS-NLMP]
18 */
19
20 #include <sys/types.h>
21 #include <sys/byteorder.h>
22 #include <strings.h>
23 #include "smbd.h"
24 #include "smbd_authsvc.h"
25 #include "netsmb/ntlmssp.h"
26 #include <assert.h>
27
28 /* A shorter alias for a crazy long name from [MS-NLMP] */
29 #define NTLMSSP_NEGOTIATE_NTLM2 \
30 NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY
31
32 /* Need this in a header somewhere */
33 #ifdef _LITTLE_ENDIAN
34 /* little-endian values on little-endian */
35 #define htolel(x) ((uint32_t)(x))
36 #define letohl(x) ((uint32_t)(x))
37 #else /* (BYTE_ORDER == LITTLE_ENDIAN) */
38 /* little-endian values on big-endian (swap) */
39 #define letohl(x) BSWAP_32(x)
40 #define htolel(x) BSWAP_32(x)
41 #endif /* (BYTE_ORDER == LITTLE_ENDIAN) */
42
43 typedef struct ntlmssp_backend {
44 uint32_t expect_type;
45 uint32_t clnt_flags;
46 uint32_t srv_flags;
47 char srv_challenge[8];
48 } ntlmssp_backend_t;
49
50 struct genhdr {
51 char h_id[8]; /* "NTLMSSP" */
52 uint32_t h_type;
53 };
54
55 struct sec_buf {
56 uint16_t sb_length;
57 uint16_t sb_maxlen;
58 uint32_t sb_offset;
59 };
60
61 struct nego_hdr {
62 char h_id[8];
63 uint32_t h_type;
64 uint32_t h_flags;
65 /* workstation domain, name (place holders) */
66 uint16_t ws_dom[4];
67 uint16_t ws_name[4];
68 };
69
70 struct auth_hdr {
71 char h_id[8];
72 uint32_t h_type;
73 struct sec_buf h_lm_resp;
74 struct sec_buf h_nt_resp;
75 struct sec_buf h_domain;
76 struct sec_buf h_user;
77 struct sec_buf h_wksta;
78 struct sec_buf h_essn_key; /* encrypted session key */
79 uint32_t h_flags;
80 /* Version struct (optional) */
81 /* MIC hash (optional) */
82 };
83
84 /* Allow turning these off for debugging, etc. */
85 int smbd_signing_enabled = 1;
86
87 int smbd_constant_challenge = 0;
88 static uint8_t constant_chal[8] = {
89 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 };
90
91 static int smbd_ntlmssp_negotiate(authsvc_context_t *);
92 static int smbd_ntlmssp_authenticate(authsvc_context_t *);
93 static int encode_avpair_str(smb_msgbuf_t *, uint16_t, char *);
94 static int decode_secbuf_bin(smb_msgbuf_t *, struct sec_buf *, void **);
95 static int decode_secbuf_str(smb_msgbuf_t *, struct sec_buf *, char **);
96
97 /*
98 * Initialize this context for NTLMSSP, if possible.
99 */
100 int
101 smbd_ntlmssp_init(authsvc_context_t *ctx)
102 {
103 ntlmssp_backend_t *be;
104
105 be = malloc(sizeof (*be));
106 if (be == 0)
107 return (NT_STATUS_NO_MEMORY);
108 bzero(be, sizeof (*be));
109 be->expect_type = NTLMSSP_MSGTYPE_NEGOTIATE;
110 ctx->ctx_backend = be;
111
112 return (0);
113 }
114
115 void
116 smbd_ntlmssp_fini(authsvc_context_t *ctx)
117 {
118 free(ctx->ctx_backend);
119 }
120
121 /*
122 * Handle an auth message
123 */
124 int
125 smbd_ntlmssp_work(authsvc_context_t *ctx)
126 {
127 struct genhdr *ihdr = ctx->ctx_ibodybuf;
128 ntlmssp_backend_t *be = ctx->ctx_backend;
129 uint32_t mtype;
130 int rc;
131
132 if (ctx->ctx_ibodylen < sizeof (*ihdr))
133 return (NT_STATUS_INVALID_PARAMETER);
134
135 if (bcmp(ihdr->h_id, "NTLMSSP", 8))
136 return (NT_STATUS_INVALID_PARAMETER);
137 mtype = letohl(ihdr->h_type);
138 if (mtype != be->expect_type)
139 return (NT_STATUS_INVALID_PARAMETER);
140
141 switch (mtype) {
142 case NTLMSSP_MSGTYPE_NEGOTIATE:
143 ctx->ctx_orawtype = LSA_MTYPE_ES_CONT;
144 rc = smbd_ntlmssp_negotiate(ctx);
145 break;
146 case NTLMSSP_MSGTYPE_AUTHENTICATE:
147 ctx->ctx_orawtype = LSA_MTYPE_ES_DONE;
148 rc = smbd_ntlmssp_authenticate(ctx);
149 break;
150
151 default:
152 case NTLMSSP_MSGTYPE_CHALLENGE:
153 /* Sent by servers, not received. */
154 rc = NT_STATUS_INVALID_PARAMETER;
155 break;
156 }
157
158 return (rc);
159 }
160
161 #if (MAXHOSTNAMELEN < NETBIOS_NAME_SZ)
162 #error "MAXHOSTNAMELEN < NETBIOS_NAME_SZ"
163 #endif
164
165 /*
166 * Handle an NTLMSSP_MSGTYPE_NEGOTIATE message, and reply
167 * with an NTLMSSP_MSGTYPE_CHALLENGE message.
168 * See: [MS-NLMP] 2.2.1.1, 3.2.5.1.1
169 */
170 static int
171 smbd_ntlmssp_negotiate(authsvc_context_t *ctx)
172 {
173 char tmp_name[MAXHOSTNAMELEN];
174 ntlmssp_backend_t *be = ctx->ctx_backend;
175 struct nego_hdr *ihdr = ctx->ctx_ibodybuf;
176 smb_msgbuf_t mb;
177 uint8_t *save_scan;
178 int secmode;
179 int mbflags;
180 int rc;
181 size_t var_start, var_end;
182 uint16_t var_size;
183
184 if (ctx->ctx_ibodylen < sizeof (*ihdr))
185 return (NT_STATUS_INVALID_PARAMETER);
186 be->clnt_flags = letohl(ihdr->h_flags);
187
188 /*
189 * Looks like we can ignore ws_dom, ws_name.
190 * Otherwise would parse those here.
191 */
192
193 secmode = smb_config_get_secmode();
194 if (smbd_constant_challenge) {
195 (void) memcpy(be->srv_challenge, constant_chal,
196 sizeof (be->srv_challenge));
197 } else {
198 randomize(be->srv_challenge, sizeof (be->srv_challenge));
199 }
200
201 /*
202 * Compute srv_flags
203 */
204 be->srv_flags =
205 NTLMSSP_REQUEST_TARGET |
206 NTLMSSP_NEGOTIATE_NTLM |
207 NTLMSSP_NEGOTIATE_TARGET_INFO;
208 be->srv_flags |= be->clnt_flags & (
209 NTLMSSP_NEGOTIATE_NTLM2 |
210 NTLMSSP_NEGOTIATE_128 |
211 NTLMSSP_NEGOTIATE_KEY_EXCH |
212 NTLMSSP_NEGOTIATE_56);
213
214 if (smbd_signing_enabled) {
215 be->srv_flags |= be->clnt_flags & (
216 NTLMSSP_NEGOTIATE_SIGN |
217 NTLMSSP_NEGOTIATE_SEAL |
218 NTLMSSP_NEGOTIATE_ALWAYS_SIGN);
219 }
220
221 if (be->clnt_flags & NTLMSSP_NEGOTIATE_UNICODE)
222 be->srv_flags |= NTLMSSP_NEGOTIATE_UNICODE;
223 else if (be->clnt_flags & NTLMSSP_NEGOTIATE_OEM)
224 be->srv_flags |= NTLMSSP_NEGOTIATE_OEM;
225
226 /* LM Key is mutually exclusive with NTLM2 */
227 if ((be->srv_flags & NTLMSSP_NEGOTIATE_NTLM2) == 0 &&
228 (be->clnt_flags & NTLMSSP_NEGOTIATE_LM_KEY) != 0)
229 be->srv_flags |= NTLMSSP_NEGOTIATE_LM_KEY;
230
231 /* Get our "target name" */
232 if (secmode == SMB_SECMODE_DOMAIN) {
233 be->srv_flags |= NTLMSSP_TARGET_TYPE_DOMAIN;
234 rc = smb_getdomainname(tmp_name, NETBIOS_NAME_SZ);
235 } else {
236 be->srv_flags |= NTLMSSP_TARGET_TYPE_SERVER;
237 rc = smb_getnetbiosname(tmp_name, NETBIOS_NAME_SZ);
238 }
239 if (rc)
240 goto errout;
241
242 /*
243 * Build the NTLMSSP_MSGTYPE_CHALLENGE message.
244 */
245 mbflags = SMB_MSGBUF_NOTERM;
246 if (be->srv_flags & NTLMSSP_NEGOTIATE_UNICODE)
247 mbflags |= SMB_MSGBUF_UNICODE;
248 smb_msgbuf_init(&mb, ctx->ctx_obodybuf, ctx->ctx_obodylen, mbflags);
249
250 /*
251 * Fixed size parts
252 */
253 rc = smb_msgbuf_encode(
254 &mb, "8clwwll8cllwwl", /* offset, name (fmt) */
255 "NTLMSSP", /* 0: signature (8c) */
256 NTLMSSP_MSGTYPE_CHALLENGE, /* 8: type (l) */
257 0, 0, 0, /* filled later: 12: target name (wwl) */
258 be->srv_flags, /* 20: flags (l) */
259 be->srv_challenge, /* 24: (8c) */
260 0, 0, /* 32: reserved (ll) */
261 0, 0, 0); /* filled later: 40: target info (wwl) */
262 #define TARGET_NAME_OFFSET 12
263 #define TARGET_INFO_OFFSET 40
264 if (rc < 0)
265 goto errout;
266
267 /*
268 * Variable length parts.
269 *
270 * Target name
271 */
272 var_start = smb_msgbuf_used(&mb);
273 rc = smb_msgbuf_encode(&mb, "u", tmp_name);
274 var_end = smb_msgbuf_used(&mb);
275 var_size = (uint16_t)(var_end - var_start);
276 if (rc < 0)
277 goto errout;
278
279 /* overwrite target name offset+lengths */
280 save_scan = mb.scan;
281 mb.scan = mb.base + TARGET_NAME_OFFSET;
282 (void) smb_msgbuf_encode(&mb, "wwl", var_size, var_size, var_start);
283 mb.scan = save_scan;
284
285 /*
286 * Target info (AvPairList)
287 *
288 * These AV pairs are like our name/value pairs, but have
289 * numeric identifiers instead of names. There are many
290 * of these, but we put only the four expected by Windows:
291 * NetBIOS computer name
292 * NetBIOS domain name
293 * DNS computer name
294 * DNS domain name
295 * Note that "domain" above (even "DNS domain") refers to
296 * the AD domain of which we're a member, which may be
297 * _different_ from the configured DNS domain.
298 *
299 * Also note that in "workgroup" mode (not a domain member)
300 * all "domain" fields should be set to the same values as
301 * the "computer" fields ("bare" host name, not FQDN).
302 */
303 var_start = smb_msgbuf_used(&mb);
304
305 /* NetBIOS Computer Name */
306 if (smb_getnetbiosname(tmp_name, NETBIOS_NAME_SZ))
307 goto errout;
308 if (encode_avpair_str(&mb, MsvAvNbComputerName, tmp_name) < 0)
309 goto errout;
310
311 if (secmode != SMB_SECMODE_DOMAIN) {
312 /*
313 * Workgroup mode. Set all to hostname.
314 * tmp_name = netbios hostname from above.
315 */
316 if (encode_avpair_str(&mb, MsvAvNbDomainName, tmp_name) < 0)
317 goto errout;
318 /*
319 * Want the bare computer name here (not FQDN).
320 */
321 if (smb_gethostname(tmp_name, MAXHOSTNAMELEN, SMB_CASE_LOWER))
322 goto errout;
323 if (encode_avpair_str(&mb, MsvAvDnsComputerName, tmp_name) < 0)
324 goto errout;
325 if (encode_avpair_str(&mb, MsvAvDnsDomainName, tmp_name) < 0)
326 goto errout;
327 } else {
328 /*
329 * Domain mode. Use real host and domain values.
330 */
331
332 /* NetBIOS Domain Name */
333 if (smb_getdomainname(tmp_name, NETBIOS_NAME_SZ))
334 goto errout;
335 if (encode_avpair_str(&mb, MsvAvNbDomainName, tmp_name) < 0)
336 goto errout;
337
338 /* DNS Computer Name */
339 if (smb_getfqhostname(tmp_name, MAXHOSTNAMELEN))
340 goto errout;
341 if (encode_avpair_str(&mb, MsvAvDnsComputerName, tmp_name) < 0)
342 goto errout;
343
344 /* DNS Domain Name */
345 if (smb_getfqdomainname(tmp_name, MAXHOSTNAMELEN))
346 goto errout;
347 if (encode_avpair_str(&mb, MsvAvDnsDomainName, tmp_name) < 0)
348 goto errout;
349 }
350
351 /* End marker */
352 if (smb_msgbuf_encode(&mb, "ww", MsvAvEOL, 0) < 0)
353 goto errout;
354 var_end = smb_msgbuf_used(&mb);
355 var_size = (uint16_t)(var_end - var_start);
356
357 /* overwrite target offset+lengths */
358 save_scan = mb.scan;
359 mb.scan = mb.base + TARGET_INFO_OFFSET;
360 (void) smb_msgbuf_encode(&mb, "wwl", var_size, var_size, var_start);
361 mb.scan = save_scan;
362
363 ctx->ctx_obodylen = smb_msgbuf_used(&mb);
364 smb_msgbuf_term(&mb);
365
366 be->expect_type = NTLMSSP_MSGTYPE_AUTHENTICATE;
367
368 return (0);
369
370 errout:
371 smb_msgbuf_term(&mb);
372 return (NT_STATUS_INTERNAL_ERROR);
373 }
374
375 static int
376 encode_avpair_str(smb_msgbuf_t *mb, uint16_t AvId, char *name)
377 {
378 int rc;
379 uint16_t len;
380
381 len = smb_wcequiv_strlen(name);
382 rc = smb_msgbuf_encode(mb, "wwU", AvId, len, name);
383 return (rc);
384 }
385
386 /*
387 * Handle an NTLMSSP_MSGTYPE_AUTHENTICATE message.
388 * See: [MS-NLMP] 2.2.1.3, 3.2.5.1.2
389 */
390 static int
391 smbd_ntlmssp_authenticate(authsvc_context_t *ctx)
392 {
393 struct auth_hdr hdr;
394 smb_msgbuf_t mb;
395 smb_logon_t user_info;
396 smb_token_t *token = NULL;
397 ntlmssp_backend_t *be = ctx->ctx_backend;
398 void *lm_resp;
399 void *nt_resp;
400 char *domain;
401 char *user;
402 char *wksta;
403 void *essn_key; /* encrypted session key (optional) */
404 int mbflags;
405 uint_t status = NT_STATUS_INTERNAL_ERROR;
406 char combined_challenge[SMBAUTH_CHAL_SZ];
407 unsigned char kxkey[SMBAUTH_HASH_SZ];
408 boolean_t ntlm_v1x = B_FALSE;
409
410 bzero(&user_info, sizeof (user_info));
411
412 /*
413 * Parse the NTLMSSP_MSGTYPE_AUTHENTICATE message.
414 */
415 if (ctx->ctx_ibodylen < sizeof (hdr))
416 return (NT_STATUS_INVALID_PARAMETER);
417 mbflags = SMB_MSGBUF_NOTERM;
418 if (be->srv_flags & NTLMSSP_NEGOTIATE_UNICODE)
419 mbflags |= SMB_MSGBUF_UNICODE;
420 smb_msgbuf_init(&mb, ctx->ctx_ibodybuf, ctx->ctx_ibodylen, mbflags);
421 bzero(&hdr, sizeof (hdr));
422
423 if (smb_msgbuf_decode(&mb, "12.") < 0)
424 goto errout;
425 if (decode_secbuf_bin(&mb, &hdr.h_lm_resp, &lm_resp) < 0)
426 goto errout;
427 if (decode_secbuf_bin(&mb, &hdr.h_nt_resp, &nt_resp) < 0)
428 goto errout;
429 if (decode_secbuf_str(&mb, &hdr.h_domain, &domain) < 0)
430 goto errout;
431 if (decode_secbuf_str(&mb, &hdr.h_user, &user) < 0)
432 goto errout;
433 if (decode_secbuf_str(&mb, &hdr.h_wksta, &wksta) < 0)
434 goto errout;
435 if (decode_secbuf_bin(&mb, &hdr.h_essn_key, &essn_key) < 0)
436 goto errout;
437 if (smb_msgbuf_decode(&mb, "l", &be->clnt_flags) < 0)
438 goto errout;
439
440 if (be->clnt_flags & NTLMSSP_NEGOTIATE_KEY_EXCH) {
441 if (hdr.h_essn_key.sb_length < 16 || essn_key == NULL)
442 goto errout;
443 }
444
445 user_info.lg_level = NETR_NETWORK_LOGON;
446 user_info.lg_flags = 0;
447
448 user_info.lg_ntlm_flags = be->clnt_flags;
449 user_info.lg_username = (user) ? user : "";
450 user_info.lg_domain = (domain) ? domain : "";
451 user_info.lg_workstation = (wksta) ? wksta : "";
452
453 user_info.lg_clnt_ipaddr =
454 ctx->ctx_clinfo.lci_clnt_ipaddr;
455 user_info.lg_local_port = 445;
456
457 user_info.lg_challenge_key.len = SMBAUTH_CHAL_SZ;
458 user_info.lg_challenge_key.val = (uint8_t *)be->srv_challenge;
459
460 user_info.lg_nt_password.len = hdr.h_nt_resp.sb_length;
461 user_info.lg_nt_password.val = nt_resp;
462
463 user_info.lg_lm_password.len = hdr.h_lm_resp.sb_length;
464 user_info.lg_lm_password.val = lm_resp;
465
466 user_info.lg_native_os = ctx->ctx_clinfo.lci_native_os;
467 user_info.lg_native_lm = ctx->ctx_clinfo.lci_native_lm;
468
469 /*
470 * If we're doing extended session security, the challenge
471 * this OWF was computed with is different. [MS-NLMP 3.3.1]
472 * It's: MD5(concat(ServerChallenge,ClientChallenge))
473 * where the ClientChallenge is in the LM resp. field.
474 */
475 if (user_info.lg_nt_password.len == SMBAUTH_LM_RESP_SZ &&
476 user_info.lg_lm_password.len >= SMBAUTH_CHAL_SZ &&
477 (be->clnt_flags & NTLMSSP_NEGOTIATE_NTLM2) != 0) {
478 smb_auth_ntlm2_mkchallenge(combined_challenge,
479 be->srv_challenge, lm_resp);
480 user_info.lg_challenge_key.val =
481 (uint8_t *)combined_challenge;
482 user_info.lg_lm_password.len = 0;
483 ntlm_v1x = B_TRUE;
484 }
485
486 /*
487 * This (indirectly) calls smb_auth_validate() to
488 * check that the client gave us a valid hash.
489 */
490 token = smbd_user_auth_logon(&user_info);
491 if (token == NULL) {
492 status = user_info.lg_status;
493 if (status == 0) /* should not happen */
494 status = NT_STATUS_INTERNAL_ERROR;
495 goto errout;
496 }
497
498 if (token->tkn_ssnkey.val != NULL &&
499 token->tkn_ssnkey.len == SMBAUTH_HASH_SZ) {
500
501 /*
502 * At this point, token->tkn_session_key is the
503 * "Session Base Key" [MS-NLMP] 3.2.5.1.2
504 * Compute the final session key. First need the
505 * "Key Exchange Key" [MS-NLMP] 3.4.5.1
506 */
507 if (ntlm_v1x) {
508 smb_auth_ntlm2_kxkey(kxkey,
509 be->srv_challenge, lm_resp,
510 token->tkn_ssnkey.val);
511 } else {
512 /* KXKEY is the Session Base Key. */
513 (void) memcpy(kxkey, token->tkn_ssnkey.val,
514 SMBAUTH_HASH_SZ);
515 }
516
517 /*
518 * If the client give us an encrypted session key,
519 * decrypt it (RC4) using the "key exchange key".
520 */
521 if (be->clnt_flags & NTLMSSP_NEGOTIATE_KEY_EXCH) {
522 /* RC4 args: result, key, data */
523 (void) smb_auth_RC4(token->tkn_ssnkey.val,
524 SMBAUTH_HASH_SZ, kxkey, SMBAUTH_HASH_SZ,
525 essn_key, hdr.h_essn_key.sb_length);
526 } else {
527 /* Final key is the KXKEY */
528 (void) memcpy(token->tkn_ssnkey.val, kxkey,
529 SMBAUTH_HASH_SZ);
530 }
531 }
532
533 ctx->ctx_token = token;
534 ctx->ctx_obodylen = 0;
535
536 smb_msgbuf_term(&mb);
537 return (0);
538
539 errout:
540 smb_msgbuf_term(&mb);
541 return (status);
542 }
543
544 static int
545 decode_secbuf_bin(smb_msgbuf_t *mb, struct sec_buf *sb, void **binp)
546 {
547 int rc;
548
549 *binp = NULL;
550 rc = smb_msgbuf_decode(
551 mb, "wwl",
552 &sb->sb_length,
553 &sb->sb_maxlen,
554 &sb->sb_offset);
555 if (rc < 0)
556 return (rc);
557
558 if (sb->sb_offset > mb->max)
559 return (SMB_MSGBUF_UNDERFLOW);
560 if (sb->sb_length > (mb->max - sb->sb_offset))
561 return (SMB_MSGBUF_UNDERFLOW);
562 if (sb->sb_length == 0)
563 return (rc);
564
565 *binp = mb->base + sb->sb_offset;
566 return (0);
567 }
568
569 static int
570 decode_secbuf_str(smb_msgbuf_t *mb, struct sec_buf *sb, char **cpp)
571 {
572 uint8_t *save_scan;
573 int rc;
574
575 *cpp = NULL;
576 rc = smb_msgbuf_decode(
577 mb, "wwl",
578 &sb->sb_length,
579 &sb->sb_maxlen,
580 &sb->sb_offset);
581 if (rc < 0)
582 return (rc);
583
584 if (sb->sb_offset > mb->max)
585 return (SMB_MSGBUF_UNDERFLOW);
586 if (sb->sb_length > (mb->max - sb->sb_offset))
587 return (SMB_MSGBUF_UNDERFLOW);
588 if (sb->sb_length == 0)
589 return (rc);
590
591 save_scan = mb->scan;
592 mb->scan = mb->base + sb->sb_offset;
593 rc = smb_msgbuf_decode(mb, "#u", (int)sb->sb_length, cpp);
594 mb->scan = save_scan;
595
596 return (rc);
597 }