xref: /titanic_51/usr/src/lib/libsmbfs/smb/ssnsetup.c (revision 90b1de135fcfa7ce4adc9138a885aa94bbcef04f)
1 /*
2  * Copyright (c) 2000-2001 Boris Popov
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *    This product includes software developed by Boris Popov.
16  * 4. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 
33 /*
34  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
35  * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
36  */
37 
38 /*
39  * SMB Session Setup, and related.
40  */
41 
42 #include <errno.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <unistd.h>
46 #include <strings.h>
47 #include <netdb.h>
48 #include <libintl.h>
49 #include <xti.h>
50 #include <assert.h>
51 
52 #include <sys/types.h>
53 #include <sys/time.h>
54 #include <sys/byteorder.h>
55 #include <sys/socket.h>
56 #include <sys/fcntl.h>
57 
58 #include <netinet/in.h>
59 #include <netinet/tcp.h>
60 #include <arpa/inet.h>
61 
62 #include <netsmb/mchain.h>
63 #include <netsmb/netbios.h>
64 #include <netsmb/smb_dev.h>
65 #include <netsmb/smb.h>
66 
67 #include <netsmb/smb_lib.h>
68 #include <netsmb/nb_lib.h>
69 
70 #include "private.h"
71 #include "charsets.h"
72 #include "ntlm.h"
73 #include "smb_crypt.h"
74 
75 
76 static int
77 smb__ssnsetup(struct smb_ctx *ctx,
78 	struct mbdata *mbc1, struct mbdata *mbc2,
79 	uint32_t *statusp, uint16_t *actionp);
80 
81 /*
82  * Session Setup: NULL session (anonymous)
83  */
84 int
85 smb_ssnsetup_null(struct smb_ctx *ctx)
86 {
87 	int err;
88 	uint32_t ntstatus;
89 	uint16_t action = 0;
90 
91 	if (ctx->ct_clnt_caps & SMB_CAP_EXT_SECURITY) {
92 		/* Should not get here with... */
93 		err = EINVAL;
94 		goto out;
95 	}
96 
97 	err = smb__ssnsetup(ctx, NULL, NULL, &ntstatus, &action);
98 	if (err)
99 		goto out;
100 
101 	DPRINT("status 0x%x action 0x%x", ntstatus, (int)action);
102 	if (ntstatus != 0)
103 		err = EAUTH;
104 
105 out:
106 	return (err);
107 }
108 
109 
110 /*
111  * SMB Session Setup, using NTLMv1 (and maybe LMv1)
112  */
113 int
114 smb_ssnsetup_ntlm1(struct smb_ctx *ctx)
115 {
116 	struct mbdata lm_mbc, nt_mbc;
117 	int err;
118 	uint32_t ntstatus;
119 	uint16_t action = 0;
120 
121 	if (ctx->ct_clnt_caps & SMB_CAP_EXT_SECURITY) {
122 		/* Should not get here with... */
123 		err = EINVAL;
124 		goto out;
125 	}
126 
127 	/* Make mb_done calls at out safe. */
128 	bzero(&lm_mbc, sizeof (lm_mbc));
129 	bzero(&nt_mbc, sizeof (nt_mbc));
130 
131 	/* Put the LM,NTLM responses (as mbdata). */
132 	err = ntlm_put_v1_responses(ctx, &lm_mbc, &nt_mbc);
133 	if (err)
134 		goto out;
135 
136 	if ((ctx->ct_vcflags & SMBV_WILL_SIGN) != 0 &&
137 	    (ctx->ct_hflags2 & SMB_FLAGS2_SECURITY_SIGNATURE) == 0) {
138 		err = ntlm_build_mac_key(ctx, &nt_mbc);
139 		if (err)
140 			goto out;
141 		/* OK, start signing! */
142 		ctx->ct_hflags2 |= SMB_FLAGS2_SECURITY_SIGNATURE;
143 	}
144 
145 	err = smb__ssnsetup(ctx, &lm_mbc, &nt_mbc, &ntstatus, &action);
146 	if (err)
147 		goto out;
148 
149 	DPRINT("status 0x%x action 0x%x", ntstatus, (int)action);
150 	if (ntstatus != 0)
151 		err = EAUTH;
152 
153 out:
154 	mb_done(&lm_mbc);
155 	mb_done(&nt_mbc);
156 
157 	return (err);
158 }
159 
160 /*
161  * SMB Session Setup, using NTLMv2 (and LMv2)
162  */
163 int
164 smb_ssnsetup_ntlm2(struct smb_ctx *ctx)
165 {
166 	struct mbdata lm_mbc, nt_mbc, ti_mbc;
167 	int err;
168 	uint32_t ntstatus;
169 	uint16_t action = 0;
170 
171 	if (ctx->ct_clnt_caps & SMB_CAP_EXT_SECURITY) {
172 		/* Should not get here with... */
173 		err = EINVAL;
174 		goto out;
175 	}
176 
177 	/* Make mb_done calls at out safe. */
178 	bzero(&lm_mbc, sizeof (lm_mbc));
179 	bzero(&nt_mbc, sizeof (nt_mbc));
180 	bzero(&ti_mbc, sizeof (ti_mbc));
181 
182 	/* Build the NTLMv2 "target info" blob (as mbdata) */
183 	err = ntlm_build_target_info(ctx, NULL, &ti_mbc);
184 	if (err)
185 		goto out;
186 
187 	/* Put the LMv2, NTLMv2 responses (as mbdata). */
188 	err = ntlm_put_v2_responses(ctx, &ti_mbc, &lm_mbc, &nt_mbc);
189 	if (err)
190 		goto out;
191 
192 	if ((ctx->ct_vcflags & SMBV_WILL_SIGN) != 0 &&
193 	    (ctx->ct_hflags2 & SMB_FLAGS2_SECURITY_SIGNATURE) == 0) {
194 		err = ntlm_build_mac_key(ctx, &nt_mbc);
195 		if (err)
196 			goto out;
197 		/* OK, start signing! */
198 		ctx->ct_hflags2 |= SMB_FLAGS2_SECURITY_SIGNATURE;
199 	}
200 
201 	err = smb__ssnsetup(ctx, &lm_mbc, &nt_mbc, &ntstatus, &action);
202 	if (err)
203 		goto out;
204 
205 	DPRINT("status 0x%x action 0x%x", ntstatus, (int)action);
206 	if (ntstatus != 0)
207 		err = EAUTH;
208 
209 out:
210 	mb_done(&ti_mbc);
211 	mb_done(&lm_mbc);
212 	mb_done(&nt_mbc);
213 
214 	return (err);
215 }
216 
217 int
218 smb_ssnsetup_spnego(struct smb_ctx *ctx, struct mbdata *hint_mb)
219 {
220 	struct mbdata send_mb, recv_mb;
221 	int		err;
222 	uint32_t	ntstatus;
223 	uint16_t	action = 0;
224 
225 	err = ssp_ctx_create_client(ctx, hint_mb);
226 	if (err)
227 		goto out;
228 
229 	bzero(&send_mb, sizeof (send_mb));
230 	bzero(&recv_mb, sizeof (recv_mb));
231 
232 	/* NULL input indicates first call. */
233 	err = ssp_ctx_next_token(ctx, NULL, &send_mb);
234 	if (err)
235 		goto out;
236 
237 	for (;;) {
238 		err = smb__ssnsetup(ctx, &send_mb, &recv_mb,
239 		    &ntstatus, &action);
240 		if (err)
241 			goto out;
242 		if (ntstatus == 0)
243 			break; /* normal loop termination */
244 		if (ntstatus != NT_STATUS_MORE_PROCESSING_REQUIRED) {
245 			err = EAUTH;
246 			goto out;
247 		}
248 
249 		/* middle calls get both in, out */
250 		err = ssp_ctx_next_token(ctx, &recv_mb, &send_mb);
251 		if (err)
252 			goto out;
253 	}
254 	DPRINT("status 0x%x action 0x%x", ntstatus, (int)action);
255 
256 	/* NULL output indicates last call. */
257 	(void) ssp_ctx_next_token(ctx, &recv_mb, NULL);
258 
259 out:
260 	ssp_ctx_destroy(ctx);
261 
262 	return (err);
263 }
264 
265 /*
266  * Session Setup function used for all the forms we support.
267  * To allow this sharing, the crypto stuff is computed by
268  * callers and passed in as mbdata chains.  Also, the args
269  * have different meanings for extended security vs. old.
270  * Some may be used as either IN or OUT parameters.
271  *
272  * For NTLM (v1, v2), all parameters are inputs
273  * 	mbc1: [in] LM password hash
274  * 	mbc2: [in] NT password hash
275  * For Extended security (spnego)
276  *	mbc1: [in]  outgoing blob data
277  *	mbc2: [out] received blob data
278  * For both forms, these are optional:
279  *	statusp: [out] NT status
280  *	actionp: [out] Logon Action (i.e. SMB_ACT_GUEST)
281  */
282 static int
283 smb__ssnsetup(struct smb_ctx *ctx,
284 	struct mbdata *mbc1, struct mbdata *mbc2,
285 	uint32_t *statusp, uint16_t *actionp)
286 {
287 	static const char NativeOS[] = "Solaris";
288 	static const char LanMan[] = "NETSMB";
289 	struct smb_sopt *sv = &ctx->ct_sopt;
290 	struct smb_iods *is = &ctx->ct_iods;
291 	struct smb_rq	*rqp = NULL;
292 	struct mbdata	*mbp;
293 	struct mbuf	*m;
294 	int err, uc;
295 	uint32_t caps;
296 	uint16_t bc, len1, len2, sblen;
297 	uint8_t wc;
298 
299 	caps = ctx->ct_clnt_caps;
300 	uc = ctx->ct_hflags2 & SMB_FLAGS2_UNICODE;
301 
302 	err = smb_rq_init(ctx, SMB_COM_SESSION_SETUP_ANDX, &rqp);
303 	if (err)
304 		goto out;
305 
306 	/*
307 	 * Build the SMB request.
308 	 */
309 	mbp = &rqp->rq_rq;
310 	smb_rq_wstart(rqp);
311 	mb_put_uint16le(mbp, 0xff);		/* 0: AndXCommand */
312 	mb_put_uint16le(mbp, 0);		/* 1: AndXOffset */
313 	mb_put_uint16le(mbp, sv->sv_maxtx);	/* 2: MaxBufferSize */
314 	mb_put_uint16le(mbp, sv->sv_maxmux);	/* 3: MaxMpxCount */
315 	mb_put_uint16le(mbp, 1);		/* 4: VcNumber */
316 	mb_put_uint32le(mbp, sv->sv_skey);	/* 5,6: Session Key */
317 
318 	if (caps & SMB_CAP_EXT_SECURITY) {
319 		len1 = mbc1 ? mbc1->mb_count : 0;
320 		mb_put_uint16le(mbp, len1);	/* 7: Sec. Blob Len */
321 		mb_put_uint32le(mbp, 0);	/* 8,9: reserved */
322 		mb_put_uint32le(mbp, caps);	/* 10,11: Capabilities */
323 		smb_rq_wend(rqp);		/* 12: Byte Count */
324 		smb_rq_bstart(rqp);
325 		if (mbc1 && mbc1->mb_top) {
326 			mb_put_mbuf(mbp, mbc1->mb_top);	/* sec. blob */
327 			mbc1->mb_top = NULL; /* consumed */
328 		}
329 		/* mbc2 is required below */
330 		if (mbc2 == NULL) {
331 			err = EINVAL;
332 			goto out;
333 		}
334 	} else {
335 		len1 = mbc1 ? mbc1->mb_count : 0;
336 		len2 = mbc2 ? mbc2->mb_count : 0;
337 		mb_put_uint16le(mbp, len1);	/* 7: LM pass. len */
338 		mb_put_uint16le(mbp, len2);	/* 8: NT pass. len */
339 		mb_put_uint32le(mbp, 0);	/* 9,10: reserved */
340 		mb_put_uint32le(mbp, caps);	/* 11,12: Capabilities */
341 		smb_rq_wend(rqp);		/* 13: Byte Count */
342 		smb_rq_bstart(rqp);
343 		if (mbc1 && mbc1->mb_top) {
344 			mb_put_mbuf(mbp, mbc1->mb_top);	/* LM password */
345 			mbc1->mb_top = NULL; /* consumed */
346 		}
347 		if (mbc2 && mbc2->mb_top) {
348 			mb_put_mbuf(mbp, mbc2->mb_top);	/* NT password */
349 			mbc2->mb_top = NULL; /* consumed */
350 		}
351 		mb_put_string(mbp, ctx->ct_user, uc);
352 		mb_put_string(mbp, ctx->ct_domain, uc);
353 	}
354 	mb_put_string(mbp, NativeOS, uc);
355 	mb_put_string(mbp, LanMan, uc);
356 	smb_rq_bend(rqp);
357 
358 	err = smb_rq_internal(ctx, rqp);
359 	if (err)
360 		goto out;
361 
362 	if (statusp)
363 		*statusp = rqp->rq_status;
364 
365 	/*
366 	 * If we have a real error, the response probably has
367 	 * no more data, so don't try to parse any more.
368 	 * Note: err=0, means rq_status is valid.
369 	 */
370 	if (rqp->rq_status != 0 &&
371 	    rqp->rq_status != NT_STATUS_MORE_PROCESSING_REQUIRED) {
372 		goto out;
373 	}
374 
375 	/*
376 	 * Parse the reply
377 	 */
378 	uc = rqp->rq_hflags2 & SMB_FLAGS2_UNICODE;
379 	is->is_smbuid = rqp->rq_uid;
380 	mbp = &rqp->rq_rp;
381 
382 	err = md_get_uint8(mbp, &wc);
383 	if (err)
384 		goto out;
385 
386 	err = EBADRPC; /* for any problems in this section */
387 	if (caps & SMB_CAP_EXT_SECURITY) {
388 		if (wc != 4)
389 			goto out;
390 		md_get_uint16le(mbp, NULL);	/* secondary cmd */
391 		md_get_uint16le(mbp, NULL);	/* andxoffset */
392 		md_get_uint16le(mbp, actionp);	/* action */
393 		md_get_uint16le(mbp, &sblen);	/* sec. blob len */
394 		md_get_uint16le(mbp, &bc);	/* byte count */
395 		/*
396 		 * Get the security blob, after
397 		 * sanity-checking the length.
398 		 */
399 		if (sblen == 0 || bc < sblen)
400 			goto out;
401 		err = md_get_mbuf(mbp, sblen, &m);
402 		if (err)
403 			goto out;
404 		mb_initm(mbc2, m);
405 		mbc2->mb_count = sblen;
406 	} else {
407 		if (wc != 3)
408 			goto out;
409 		md_get_uint16le(mbp, NULL);	/* secondary cmd */
410 		md_get_uint16le(mbp, NULL);	/* andxoffset */
411 		md_get_uint16le(mbp, actionp);	/* action */
412 		err = md_get_uint16le(mbp, &bc); /* byte count */
413 		if (err)
414 			goto out;
415 	}
416 
417 	/*
418 	 * Native OS, LANMGR, & Domain follow here.
419 	 * Parse these strings and store for later.
420 	 * If unicode, they should be aligned.
421 	 *
422 	 * Note that with Extended security, we may use
423 	 * multiple calls to this function.  Only parse
424 	 * these strings on the last one (status == 0).
425 	 * Ditto for the CAP_LARGE work-around.
426 	 */
427 	if (rqp->rq_status != 0)
428 		goto out;
429 
430 	/* Ignore any parsing errors for these strings. */
431 	err = md_get_string(mbp, &ctx->ct_srv_OS, uc);
432 	DPRINT("server OS: %s", err ? "?" : ctx->ct_srv_OS);
433 	err = md_get_string(mbp, &ctx->ct_srv_LM, uc);
434 	DPRINT("server LM: %s", err ? "?" : ctx->ct_srv_LM);
435 	/*
436 	 * There's sometimes a server domain folloing
437 	 * at this point, but we don't need it.
438 	 */
439 
440 	/* Success! (See Ignore any ... above) */
441 	err = 0;
442 
443 	/*
444 	 * Windows systems don't suport CAP_LARGE_READX,WRITEX
445 	 * when signing is enabled, so adjust sv_caps.
446 	 */
447 	if (ctx->ct_srv_OS &&
448 	    0 == strncmp(ctx->ct_srv_OS, "Windows ", 8)) {
449 		DPRINT("Server is Windows");
450 		if (ctx->ct_vcflags & SMBV_WILL_SIGN) {
451 			DPRINT("disable CAP_LARGE_(r/w)");
452 			ctx->ct_sopt.sv_caps &=
453 			    ~(SMB_CAP_LARGE_READX | SMB_CAP_LARGE_WRITEX);
454 		}
455 	}
456 
457 out:
458 	if (rqp)
459 		smb_rq_done(rqp);
460 
461 	return (err);
462 }
463