2 Unix SMB/CIFS implementation.
5 Copyright (C) Stefan Metzmacher 2009
6 Copyright (C) Jeremy Allison 2010
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "smbd/smbd.h"
24 #include "smbd/globals.h"
25 #include "../libcli/smb/smb_common.h"
26 #include "../auth/gensec/gensec.h"
28 #include "../lib/tsocket/tsocket.h"
29 #include "../libcli/security/security.h"
30 #include "../lib/util/tevent_ntstatus.h"
31 #include "lib/crypto/sha512.h"
32 #include "lib/crypto/aes.h"
33 #include "lib/crypto/aes_ccm_128.h"
34 #include "lib/crypto/aes_gcm_128.h"
36 static struct tevent_req *smbd_smb2_session_setup_wrap_send(TALLOC_CTX *mem_ctx,
37 struct tevent_context *ev,
38 struct smbd_smb2_request *smb2req,
39 uint64_t in_session_id,
41 uint8_t in_security_mode,
42 uint64_t in_previous_session_id,
43 DATA_BLOB in_security_buffer);
44 static NTSTATUS smbd_smb2_session_setup_wrap_recv(struct tevent_req *req,
45 uint16_t *out_session_flags,
47 DATA_BLOB *out_security_buffer,
48 uint64_t *out_session_id);
50 static void smbd_smb2_request_sesssetup_done(struct tevent_req *subreq);
52 NTSTATUS smbd_smb2_request_process_sesssetup(struct smbd_smb2_request *smb2req)
55 const uint8_t *inbody;
56 uint64_t in_session_id;
58 uint8_t in_security_mode;
59 uint64_t in_previous_session_id;
60 uint16_t in_security_offset;
61 uint16_t in_security_length;
62 DATA_BLOB in_security_buffer;
64 struct tevent_req *subreq;
66 status = smbd_smb2_request_verify_sizes(smb2req, 0x19);
67 if (!NT_STATUS_IS_OK(status)) {
68 return smbd_smb2_request_error(smb2req, status);
70 inhdr = SMBD_SMB2_IN_HDR_PTR(smb2req);
71 inbody = SMBD_SMB2_IN_BODY_PTR(smb2req);
73 in_session_id = BVAL(inhdr, SMB2_HDR_SESSION_ID);
75 in_flags = CVAL(inbody, 0x02);
76 in_security_mode = CVAL(inbody, 0x03);
77 /* Capabilities = IVAL(inbody, 0x04) */
78 /* Channel = IVAL(inbody, 0x08) */
79 in_security_offset = SVAL(inbody, 0x0C);
80 in_security_length = SVAL(inbody, 0x0E);
81 in_previous_session_id = BVAL(inbody, 0x10);
83 if (in_security_offset != (SMB2_HDR_BODY + SMBD_SMB2_IN_BODY_LEN(smb2req))) {
84 return smbd_smb2_request_error(smb2req, NT_STATUS_INVALID_PARAMETER);
87 if (in_security_length > SMBD_SMB2_IN_DYN_LEN(smb2req)) {
88 return smbd_smb2_request_error(smb2req, NT_STATUS_INVALID_PARAMETER);
91 in_security_buffer.data = SMBD_SMB2_IN_DYN_PTR(smb2req);
92 in_security_buffer.length = in_security_length;
94 subreq = smbd_smb2_session_setup_wrap_send(smb2req,
95 smb2req->sconn->ev_ctx,
100 in_previous_session_id,
102 if (subreq == NULL) {
103 return smbd_smb2_request_error(smb2req, NT_STATUS_NO_MEMORY);
105 tevent_req_set_callback(subreq, smbd_smb2_request_sesssetup_done, smb2req);
107 return smbd_smb2_request_pending_queue(smb2req, subreq, 500);
110 static void smbd_smb2_request_sesssetup_done(struct tevent_req *subreq)
112 struct smbd_smb2_request *smb2req =
113 tevent_req_callback_data(subreq,
114 struct smbd_smb2_request);
118 uint16_t out_session_flags = 0;
119 uint64_t out_session_id = 0;
120 uint16_t out_security_offset;
121 DATA_BLOB out_security_buffer = data_blob_null;
123 NTSTATUS error; /* transport error */
125 status = smbd_smb2_session_setup_wrap_recv(subreq,
128 &out_security_buffer,
131 if (!NT_STATUS_IS_OK(status) &&
132 !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
133 status = nt_status_squash(status);
134 error = smbd_smb2_request_error(smb2req, status);
135 if (!NT_STATUS_IS_OK(error)) {
136 smbd_server_connection_terminate(smb2req->xconn,
143 out_security_offset = SMB2_HDR_BODY + 0x08;
145 outhdr = SMBD_SMB2_OUT_HDR_PTR(smb2req);
147 outbody = smbd_smb2_generate_outbody(smb2req, 0x08);
148 if (outbody.data == NULL) {
149 error = smbd_smb2_request_error(smb2req, NT_STATUS_NO_MEMORY);
150 if (!NT_STATUS_IS_OK(error)) {
151 smbd_server_connection_terminate(smb2req->xconn,
158 SBVAL(outhdr, SMB2_HDR_SESSION_ID, out_session_id);
160 SSVAL(outbody.data, 0x00, 0x08 + 1); /* struct size */
161 SSVAL(outbody.data, 0x02,
162 out_session_flags); /* session flags */
163 SSVAL(outbody.data, 0x04,
164 out_security_offset); /* security buffer offset */
165 SSVAL(outbody.data, 0x06,
166 out_security_buffer.length); /* security buffer length */
168 outdyn = out_security_buffer;
170 error = smbd_smb2_request_done_ex(smb2req, status, outbody, &outdyn,
172 if (!NT_STATUS_IS_OK(error)) {
173 smbd_server_connection_terminate(smb2req->xconn,
179 static NTSTATUS smbd_smb2_auth_generic_return(struct smbXsrv_session *session,
180 struct smbXsrv_session_auth0 **_auth,
181 struct smbd_smb2_request *smb2req,
182 uint8_t in_security_mode,
183 struct auth_session_info *session_info,
184 uint16_t *out_session_flags,
185 uint64_t *out_session_id)
189 uint8_t session_key[16];
190 struct smbXsrv_session *x = session;
191 struct smbXsrv_session_auth0 *auth = *_auth;
192 struct smbXsrv_connection *xconn = smb2req->xconn;
199 struct _derivation signing;
200 struct _derivation encryption;
201 struct _derivation decryption;
202 struct _derivation application;
207 if (xconn->protocol >= PROTOCOL_SMB3_10) {
208 struct smbXsrv_preauth *preauth;
209 struct _derivation *d;
211 struct hc_sha512state sctx;
213 preauth = talloc_move(smb2req, &auth->preauth);
215 samba_SHA512_Init(&sctx);
216 samba_SHA512_Update(&sctx, preauth->sha512_value,
217 sizeof(preauth->sha512_value));
218 for (i = 1; i < smb2req->in.vector_count; i++) {
219 samba_SHA512_Update(&sctx,
220 smb2req->in.vector[i].iov_base,
221 smb2req->in.vector[i].iov_len);
223 samba_SHA512_Final(preauth->sha512_value, &sctx);
225 p = data_blob_const(preauth->sha512_value,
226 sizeof(preauth->sha512_value));
228 d = &derivation.signing;
229 d->label = data_blob_string_const_null("SMBSigningKey");
232 d = &derivation.decryption;
233 d->label = data_blob_string_const_null("SMBC2SCipherKey");
236 d = &derivation.encryption;
237 d->label = data_blob_string_const_null("SMBS2CCipherKey");
240 d = &derivation.application;
241 d->label = data_blob_string_const_null("SMBAppKey");
244 } else if (xconn->protocol >= PROTOCOL_SMB2_24) {
245 struct _derivation *d;
247 d = &derivation.signing;
248 d->label = data_blob_string_const_null("SMB2AESCMAC");
249 d->context = data_blob_string_const_null("SmbSign");
251 d = &derivation.decryption;
252 d->label = data_blob_string_const_null("SMB2AESCCM");
253 d->context = data_blob_string_const_null("ServerIn ");
255 d = &derivation.encryption;
256 d->label = data_blob_string_const_null("SMB2AESCCM");
257 d->context = data_blob_string_const_null("ServerOut");
259 d = &derivation.application;
260 d->label = data_blob_string_const_null("SMB2APP");
261 d->context = data_blob_string_const_null("SmbRpc");
264 if ((in_security_mode & SMB2_NEGOTIATE_SIGNING_REQUIRED) ||
265 lp_server_signing() == SMB_SIGNING_REQUIRED) {
266 x->global->signing_required = true;
269 if ((lp_smb_encrypt(-1) >= SMB_SIGNING_DESIRED) &&
270 (xconn->smb2.client.capabilities & SMB2_CAP_ENCRYPTION)) {
271 x->global->encryption_flags = SMBXSRV_ENCRYPTION_DESIRED;
274 if (lp_smb_encrypt(-1) == SMB_SIGNING_REQUIRED) {
275 x->global->encryption_flags = SMBXSRV_ENCRYPTION_REQUIRED |
276 SMBXSRV_ENCRYPTION_DESIRED;
279 if (security_session_user_level(session_info, NULL) < SECURITY_USER) {
280 /* we map anonymous to guest internally */
281 *out_session_flags |= SMB2_SESSION_FLAG_IS_GUEST;
282 *out_session_flags |= SMB2_SESSION_FLAG_IS_NULL;
283 /* force no signing */
284 x->global->signing_required = false;
288 if (guest && (x->global->encryption_flags & SMBXSRV_ENCRYPTION_REQUIRED)) {
289 DEBUG(1,("reject guest session as encryption is required\n"));
290 return NT_STATUS_ACCESS_DENIED;
293 if (xconn->smb2.server.cipher == 0) {
294 if (x->global->encryption_flags & SMBXSRV_ENCRYPTION_REQUIRED) {
295 DEBUG(1,("reject session with dialect[0x%04X] "
296 "as encryption is required\n",
297 xconn->smb2.server.dialect));
298 return NT_STATUS_ACCESS_DENIED;
301 x->global->channels[0].encryption_cipher = xconn->smb2.server.cipher;
304 if (x->global->encryption_flags & SMBXSRV_ENCRYPTION_DESIRED) {
305 *out_session_flags |= SMB2_SESSION_FLAG_ENCRYPT_DATA;
308 ZERO_STRUCT(session_key);
309 memcpy(session_key, session_info->session_key.data,
310 MIN(session_info->session_key.length, sizeof(session_key)));
312 x->global->signing_key = data_blob_talloc(x->global,
314 sizeof(session_key));
315 if (x->global->signing_key.data == NULL) {
316 ZERO_STRUCT(session_key);
317 return NT_STATUS_NO_MEMORY;
320 if (xconn->protocol >= PROTOCOL_SMB2_24) {
321 struct _derivation *d = &derivation.signing;
323 smb2_key_derivation(session_key, sizeof(session_key),
324 d->label.data, d->label.length,
325 d->context.data, d->context.length,
326 x->global->signing_key.data);
329 if (xconn->protocol >= PROTOCOL_SMB2_24) {
330 struct _derivation *d = &derivation.decryption;
332 x->global->decryption_key = data_blob_talloc(x->global,
334 sizeof(session_key));
335 if (x->global->decryption_key.data == NULL) {
336 ZERO_STRUCT(session_key);
337 return NT_STATUS_NO_MEMORY;
340 smb2_key_derivation(session_key, sizeof(session_key),
341 d->label.data, d->label.length,
342 d->context.data, d->context.length,
343 x->global->decryption_key.data);
346 if (xconn->protocol >= PROTOCOL_SMB2_24) {
347 struct _derivation *d = &derivation.encryption;
350 x->global->encryption_key = data_blob_talloc(x->global,
352 sizeof(session_key));
353 if (x->global->encryption_key.data == NULL) {
354 ZERO_STRUCT(session_key);
355 return NT_STATUS_NO_MEMORY;
358 smb2_key_derivation(session_key, sizeof(session_key),
359 d->label.data, d->label.length,
360 d->context.data, d->context.length,
361 x->global->encryption_key.data);
364 * CCM and GCM algorithms must never have their
365 * nonce wrap, or the security of the whole
366 * communication and the keys is destroyed.
367 * We must drop the connection once we have
368 * transfered too much data.
370 * NOTE: We assume nonces greater than 8 bytes.
372 generate_random_buffer((uint8_t *)&x->nonce_high_random,
373 sizeof(x->nonce_high_random));
374 switch (xconn->smb2.server.cipher) {
375 case SMB2_ENCRYPTION_AES128_CCM:
376 nonce_size = AES_CCM_128_NONCE_SIZE;
378 case SMB2_ENCRYPTION_AES128_GCM:
379 nonce_size = AES_GCM_128_IV_SIZE;
385 x->nonce_high_max = SMB2_NONCE_HIGH_MAX(nonce_size);
390 x->global->application_key = data_blob_dup_talloc(x->global,
391 x->global->signing_key);
392 if (x->global->application_key.data == NULL) {
393 ZERO_STRUCT(session_key);
394 return NT_STATUS_NO_MEMORY;
397 if (xconn->protocol >= PROTOCOL_SMB2_24) {
398 struct _derivation *d = &derivation.application;
400 smb2_key_derivation(session_key, sizeof(session_key),
401 d->label.data, d->label.length,
402 d->context.data, d->context.length,
403 x->global->application_key.data);
405 ZERO_STRUCT(session_key);
407 x->global->channels[0].signing_key = data_blob_dup_talloc(x->global->channels,
408 x->global->signing_key);
409 if (x->global->channels[0].signing_key.data == NULL) {
410 return NT_STATUS_NO_MEMORY;
413 data_blob_clear_free(&session_info->session_key);
414 session_info->session_key = data_blob_dup_talloc(session_info,
415 x->global->application_key);
416 if (session_info->session_key.data == NULL) {
417 return NT_STATUS_NO_MEMORY;
420 session->compat = talloc_zero(session, struct user_struct);
421 if (session->compat == NULL) {
422 return NT_STATUS_NO_MEMORY;
424 session->compat->session = session;
425 session->compat->homes_snum = -1;
426 session->compat->session_info = session_info;
427 session->compat->session_keystr = NULL;
428 session->compat->vuid = session->global->session_wire_id;
429 DLIST_ADD(smb2req->sconn->users, session->compat);
430 smb2req->sconn->num_users++;
432 if (security_session_user_level(session_info, NULL) >= SECURITY_USER) {
433 session->compat->homes_snum =
434 register_homes_share(session_info->unix_info->unix_name);
437 set_current_user_info(session_info->unix_info->sanitized_username,
438 session_info->unix_info->unix_name,
439 session_info->info->domain_name);
441 reload_services(smb2req->sconn, conn_snum_used, true);
443 session->status = NT_STATUS_OK;
444 session->global->auth_session_info = talloc_move(session->global,
446 session->global->auth_session_info_seqnum += 1;
447 for (i=0; i < session->global->num_channels; i++) {
448 struct smbXsrv_channel_global0 *_c =
449 &session->global->channels[i];
451 _c->auth_session_info_seqnum =
452 session->global->auth_session_info_seqnum;
454 session->global->auth_time = timeval_to_nttime(&smb2req->request_time);
455 session->global->expiration_time = gensec_expire_time(auth->gensec);
457 if (!session_claim(session)) {
458 DEBUG(1, ("smb2: Failed to claim session "
460 (unsigned long long)session->compat->vuid));
461 return NT_STATUS_LOGON_FAILURE;
465 status = smbXsrv_session_update(session);
466 if (!NT_STATUS_IS_OK(status)) {
467 DEBUG(0, ("smb2: Failed to update session for vuid=%llu - %s\n",
468 (unsigned long long)session->compat->vuid,
470 return NT_STATUS_LOGON_FAILURE;
474 * we attach the session to the request
475 * so that the response can be signed
478 smb2req->do_signing = true;
481 global_client_caps |= (CAP_LEVEL_II_OPLOCKS|CAP_STATUS32);
483 *out_session_id = session->global->session_wire_id;
488 static NTSTATUS smbd_smb2_reauth_generic_return(struct smbXsrv_session *session,
489 struct smbXsrv_session_auth0 **_auth,
490 struct smbd_smb2_request *smb2req,
491 struct auth_session_info *session_info,
492 uint16_t *out_session_flags,
493 uint64_t *out_session_id)
496 struct smbXsrv_session *x = session;
497 struct smbXsrv_session_auth0 *auth = *_auth;
498 struct smbXsrv_connection *xconn = smb2req->xconn;
503 data_blob_clear_free(&session_info->session_key);
504 session_info->session_key = data_blob_dup_talloc(session_info,
505 x->global->application_key);
506 if (session_info->session_key.data == NULL) {
507 return NT_STATUS_NO_MEMORY;
510 session->compat->session_info = session_info;
511 session->compat->vuid = session->global->session_wire_id;
513 session->compat->homes_snum =
514 register_homes_share(session_info->unix_info->unix_name);
516 set_current_user_info(session_info->unix_info->sanitized_username,
517 session_info->unix_info->unix_name,
518 session_info->info->domain_name);
520 reload_services(smb2req->sconn, conn_snum_used, true);
522 session->status = NT_STATUS_OK;
523 TALLOC_FREE(session->global->auth_session_info);
524 session->global->auth_session_info = talloc_move(session->global,
526 session->global->auth_session_info_seqnum += 1;
527 for (i=0; i < session->global->num_channels; i++) {
528 struct smbXsrv_channel_global0 *_c =
529 &session->global->channels[i];
531 _c->auth_session_info_seqnum =
532 session->global->auth_session_info_seqnum;
534 session->global->auth_time = timeval_to_nttime(&smb2req->request_time);
535 session->global->expiration_time = gensec_expire_time(auth->gensec);
538 status = smbXsrv_session_update(session);
539 if (!NT_STATUS_IS_OK(status)) {
540 DEBUG(0, ("smb2: Failed to update session for vuid=%llu - %s\n",
541 (unsigned long long)session->compat->vuid,
543 return NT_STATUS_LOGON_FAILURE;
546 conn_clear_vuid_caches(xconn->client->sconn, session->compat->vuid);
548 if (security_session_user_level(session_info, NULL) >= SECURITY_USER) {
549 smb2req->do_signing = true;
552 *out_session_id = session->global->session_wire_id;
557 struct smbd_smb2_session_setup_state {
558 struct tevent_context *ev;
559 struct smbd_smb2_request *smb2req;
560 uint64_t in_session_id;
562 uint8_t in_security_mode;
563 uint64_t in_previous_session_id;
564 DATA_BLOB in_security_buffer;
565 struct smbXsrv_session *session;
566 struct smbXsrv_session_auth0 *auth;
567 struct auth_session_info *session_info;
568 uint16_t out_session_flags;
569 DATA_BLOB out_security_buffer;
570 uint64_t out_session_id;
573 static void smbd_smb2_session_setup_gensec_done(struct tevent_req *subreq);
574 static void smbd_smb2_session_setup_previous_done(struct tevent_req *subreq);
575 static void smbd_smb2_session_setup_auth_return(struct tevent_req *req);
577 static struct tevent_req *smbd_smb2_session_setup_send(TALLOC_CTX *mem_ctx,
578 struct tevent_context *ev,
579 struct smbd_smb2_request *smb2req,
580 uint64_t in_session_id,
582 uint8_t in_security_mode,
583 uint64_t in_previous_session_id,
584 DATA_BLOB in_security_buffer)
586 struct tevent_req *req;
587 struct smbd_smb2_session_setup_state *state;
589 NTTIME now = timeval_to_nttime(&smb2req->request_time);
590 struct tevent_req *subreq;
591 struct smbXsrv_channel_global0 *c = NULL;
593 req = tevent_req_create(mem_ctx, &state,
594 struct smbd_smb2_session_setup_state);
599 state->smb2req = smb2req;
600 state->in_session_id = in_session_id;
601 state->in_flags = in_flags;
602 state->in_security_mode = in_security_mode;
603 state->in_previous_session_id = in_previous_session_id;
604 state->in_security_buffer = in_security_buffer;
606 if (in_flags & SMB2_SESSION_FLAG_BINDING) {
607 if (smb2req->xconn->protocol < PROTOCOL_SMB2_22) {
608 tevent_req_nterror(req, NT_STATUS_REQUEST_NOT_ACCEPTED);
609 return tevent_req_post(req, ev);
613 * We do not support multi channel.
615 tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
616 return tevent_req_post(req, ev);
619 if (state->in_session_id == 0) {
620 /* create a new session */
621 status = smbXsrv_session_create(state->smb2req->xconn,
622 now, &state->session);
623 if (tevent_req_nterror(req, status)) {
624 return tevent_req_post(req, ev);
626 smb2req->session = state->session;
628 if (smb2req->session == NULL) {
629 tevent_req_nterror(req, NT_STATUS_USER_SESSION_DELETED);
630 return tevent_req_post(req, ev);
633 state->session = smb2req->session;
634 status = state->session->status;
635 if (NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_SESSION_EXPIRED)) {
636 status = NT_STATUS_OK;
638 if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
639 status = NT_STATUS_OK;
641 if (tevent_req_nterror(req, status)) {
642 return tevent_req_post(req, ev);
644 if (!(in_flags & SMB2_SESSION_FLAG_BINDING)) {
645 state->session->status = NT_STATUS_MORE_PROCESSING_REQUIRED;
649 status = smbXsrv_session_find_channel(smb2req->session,
651 if (!NT_STATUS_IS_OK(status)) {
652 tevent_req_nterror(req, status);
653 return tevent_req_post(req, ev);
656 status = smbXsrv_session_find_auth(state->session, smb2req->xconn,
658 if (!NT_STATUS_IS_OK(status)) {
659 status = smbXsrv_session_create_auth(state->session,
661 in_flags, in_security_mode,
663 if (tevent_req_nterror(req, status)) {
664 return tevent_req_post(req, ev);
668 if (state->auth->gensec == NULL) {
669 status = auth_generic_prepare(state->auth,
670 state->smb2req->xconn->remote_address,
671 &state->auth->gensec);
672 if (tevent_req_nterror(req, status)) {
673 return tevent_req_post(req, ev);
676 gensec_want_feature(state->auth->gensec, GENSEC_FEATURE_SESSION_KEY);
677 gensec_want_feature(state->auth->gensec, GENSEC_FEATURE_UNIX_TOKEN);
679 status = gensec_start_mech_by_oid(state->auth->gensec,
681 if (tevent_req_nterror(req, status)) {
682 return tevent_req_post(req, ev);
686 status = smbXsrv_session_update(state->session);
687 if (tevent_req_nterror(req, status)) {
688 return tevent_req_post(req, ev);
692 subreq = gensec_update_send(state, state->ev,
694 state->in_security_buffer);
696 if (tevent_req_nomem(subreq, req)) {
697 return tevent_req_post(req, ev);
699 tevent_req_set_callback(subreq, smbd_smb2_session_setup_gensec_done, req);
704 static void smbd_smb2_session_setup_gensec_done(struct tevent_req *subreq)
706 struct tevent_req *req =
707 tevent_req_callback_data(subreq,
709 struct smbd_smb2_session_setup_state *state =
711 struct smbd_smb2_session_setup_state);
715 status = gensec_update_recv(subreq, state,
716 &state->out_security_buffer);
719 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED) &&
720 !NT_STATUS_IS_OK(status)) {
721 tevent_req_nterror(req, status);
725 if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
726 state->out_session_id = state->session->global->session_wire_id;
727 state->smb2req->preauth = state->auth->preauth;
728 tevent_req_nterror(req, status);
732 status = gensec_session_info(state->auth->gensec,
734 &state->session_info);
735 if (tevent_req_nterror(req, status)) {
739 if ((state->in_previous_session_id != 0) &&
740 (state->session->global->session_wire_id !=
741 state->in_previous_session_id))
743 subreq = smb2srv_session_close_previous_send(state, state->ev,
744 state->smb2req->xconn,
746 state->in_previous_session_id,
747 state->session->global->session_wire_id);
748 if (tevent_req_nomem(subreq, req)) {
751 tevent_req_set_callback(subreq,
752 smbd_smb2_session_setup_previous_done,
757 smbd_smb2_session_setup_auth_return(req);
760 static void smbd_smb2_session_setup_previous_done(struct tevent_req *subreq)
762 struct tevent_req *req =
763 tevent_req_callback_data(subreq,
767 status = smb2srv_session_close_previous_recv(subreq);
769 if (tevent_req_nterror(req, status)) {
773 smbd_smb2_session_setup_auth_return(req);
776 static void smbd_smb2_session_setup_auth_return(struct tevent_req *req)
778 struct smbd_smb2_session_setup_state *state =
780 struct smbd_smb2_session_setup_state);
783 if (state->session->global->auth_session_info != NULL) {
784 status = smbd_smb2_reauth_generic_return(state->session,
788 &state->out_session_flags,
789 &state->out_session_id);
790 if (tevent_req_nterror(req, status)) {
793 tevent_req_done(req);
797 status = smbd_smb2_auth_generic_return(state->session,
800 state->in_security_mode,
802 &state->out_session_flags,
803 &state->out_session_id);
804 if (tevent_req_nterror(req, status)) {
808 tevent_req_done(req);
812 static NTSTATUS smbd_smb2_session_setup_recv(struct tevent_req *req,
813 uint16_t *out_session_flags,
815 DATA_BLOB *out_security_buffer,
816 uint64_t *out_session_id)
818 struct smbd_smb2_session_setup_state *state =
820 struct smbd_smb2_session_setup_state);
823 if (tevent_req_is_nterror(req, &status)) {
824 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
825 tevent_req_received(req);
826 return nt_status_squash(status);
829 status = NT_STATUS_OK;
832 *out_session_flags = state->out_session_flags;
833 *out_security_buffer = state->out_security_buffer;
834 *out_session_id = state->out_session_id;
836 talloc_steal(mem_ctx, out_security_buffer->data);
837 tevent_req_received(req);
841 struct smbd_smb2_session_setup_wrap_state {
842 struct tevent_context *ev;
843 struct smbd_smb2_request *smb2req;
844 uint64_t in_session_id;
846 uint8_t in_security_mode;
847 uint64_t in_previous_session_id;
848 DATA_BLOB in_security_buffer;
849 uint16_t out_session_flags;
850 DATA_BLOB out_security_buffer;
851 uint64_t out_session_id;
855 static void smbd_smb2_session_setup_wrap_setup_done(struct tevent_req *subreq);
856 static void smbd_smb2_session_setup_wrap_shutdown_done(struct tevent_req *subreq);
858 static struct tevent_req *smbd_smb2_session_setup_wrap_send(TALLOC_CTX *mem_ctx,
859 struct tevent_context *ev,
860 struct smbd_smb2_request *smb2req,
861 uint64_t in_session_id,
863 uint8_t in_security_mode,
864 uint64_t in_previous_session_id,
865 DATA_BLOB in_security_buffer)
867 struct tevent_req *req;
868 struct smbd_smb2_session_setup_wrap_state *state;
869 struct tevent_req *subreq;
871 req = tevent_req_create(mem_ctx, &state,
872 struct smbd_smb2_session_setup_wrap_state);
877 state->smb2req = smb2req;
878 state->in_session_id = in_session_id;
879 state->in_flags = in_flags;
880 state->in_security_mode = in_security_mode;
881 state->in_previous_session_id = in_previous_session_id;
882 state->in_security_buffer = in_security_buffer;
884 subreq = smbd_smb2_session_setup_send(state, state->ev,
886 state->in_session_id,
888 state->in_security_mode,
889 state->in_previous_session_id,
890 state->in_security_buffer);
891 if (tevent_req_nomem(subreq, req)) {
892 return tevent_req_post(req, ev);
894 tevent_req_set_callback(subreq,
895 smbd_smb2_session_setup_wrap_setup_done, req);
900 static void smbd_smb2_session_setup_wrap_setup_done(struct tevent_req *subreq)
902 struct tevent_req *req =
903 tevent_req_callback_data(subreq,
905 struct smbd_smb2_session_setup_wrap_state *state =
907 struct smbd_smb2_session_setup_wrap_state);
910 status = smbd_smb2_session_setup_recv(subreq,
911 &state->out_session_flags,
913 &state->out_security_buffer,
914 &state->out_session_id);
916 if (NT_STATUS_IS_OK(status)) {
917 tevent_req_done(req);
920 if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
921 tevent_req_nterror(req, status);
925 if (state->smb2req->session == NULL) {
926 tevent_req_nterror(req, status);
930 state->error = status;
932 subreq = smb2srv_session_shutdown_send(state, state->ev,
933 state->smb2req->session,
935 if (tevent_req_nomem(subreq, req)) {
938 tevent_req_set_callback(subreq,
939 smbd_smb2_session_setup_wrap_shutdown_done,
943 static void smbd_smb2_session_setup_wrap_shutdown_done(struct tevent_req *subreq)
945 struct tevent_req *req =
946 tevent_req_callback_data(subreq,
948 struct smbd_smb2_session_setup_wrap_state *state =
950 struct smbd_smb2_session_setup_wrap_state);
953 status = smb2srv_session_shutdown_recv(subreq);
955 if (tevent_req_nterror(req, status)) {
960 * we may need to sign the response, so we need to keep
961 * the session until the response is sent to the wire.
963 talloc_steal(state->smb2req, state->smb2req->session);
965 tevent_req_nterror(req, state->error);
968 static NTSTATUS smbd_smb2_session_setup_wrap_recv(struct tevent_req *req,
969 uint16_t *out_session_flags,
971 DATA_BLOB *out_security_buffer,
972 uint64_t *out_session_id)
974 struct smbd_smb2_session_setup_wrap_state *state =
976 struct smbd_smb2_session_setup_wrap_state);
979 if (tevent_req_is_nterror(req, &status)) {
980 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
981 tevent_req_received(req);
982 return nt_status_squash(status);
985 status = NT_STATUS_OK;
988 *out_session_flags = state->out_session_flags;
989 *out_security_buffer = state->out_security_buffer;
990 *out_session_id = state->out_session_id;
992 talloc_steal(mem_ctx, out_security_buffer->data);
993 tevent_req_received(req);
997 static struct tevent_req *smbd_smb2_logoff_send(TALLOC_CTX *mem_ctx,
998 struct tevent_context *ev,
999 struct smbd_smb2_request *smb2req);
1000 static NTSTATUS smbd_smb2_logoff_recv(struct tevent_req *req);
1001 static void smbd_smb2_request_logoff_done(struct tevent_req *subreq);
1003 NTSTATUS smbd_smb2_request_process_logoff(struct smbd_smb2_request *req)
1006 struct tevent_req *subreq = NULL;
1008 status = smbd_smb2_request_verify_sizes(req, 0x04);
1009 if (!NT_STATUS_IS_OK(status)) {
1010 return smbd_smb2_request_error(req, status);
1013 subreq = smbd_smb2_logoff_send(req, req->sconn->ev_ctx, req);
1014 if (subreq == NULL) {
1015 return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
1017 tevent_req_set_callback(subreq, smbd_smb2_request_logoff_done, req);
1020 * Wait a long time before going async on this to allow
1021 * requests we're waiting on to finish. Set timeout to 10 secs.
1023 return smbd_smb2_request_pending_queue(req, subreq, 10000000);
1026 static void smbd_smb2_request_logoff_done(struct tevent_req *subreq)
1028 struct smbd_smb2_request *smb2req =
1029 tevent_req_callback_data(subreq,
1030 struct smbd_smb2_request);
1035 status = smbd_smb2_logoff_recv(subreq);
1036 TALLOC_FREE(subreq);
1037 if (!NT_STATUS_IS_OK(status)) {
1038 error = smbd_smb2_request_error(smb2req, status);
1039 if (!NT_STATUS_IS_OK(error)) {
1040 smbd_server_connection_terminate(smb2req->xconn,
1047 outbody = smbd_smb2_generate_outbody(smb2req, 0x04);
1048 if (outbody.data == NULL) {
1049 error = smbd_smb2_request_error(smb2req, NT_STATUS_NO_MEMORY);
1050 if (!NT_STATUS_IS_OK(error)) {
1051 smbd_server_connection_terminate(smb2req->xconn,
1058 SSVAL(outbody.data, 0x00, 0x04); /* struct size */
1059 SSVAL(outbody.data, 0x02, 0); /* reserved */
1061 error = smbd_smb2_request_done(smb2req, outbody, NULL);
1062 if (!NT_STATUS_IS_OK(error)) {
1063 smbd_server_connection_terminate(smb2req->xconn,
1069 struct smbd_smb2_logoff_state {
1070 struct smbd_smb2_request *smb2req;
1073 static void smbd_smb2_logoff_shutdown_done(struct tevent_req *subreq);
1075 static struct tevent_req *smbd_smb2_logoff_send(TALLOC_CTX *mem_ctx,
1076 struct tevent_context *ev,
1077 struct smbd_smb2_request *smb2req)
1079 struct tevent_req *req;
1080 struct smbd_smb2_logoff_state *state;
1081 struct tevent_req *subreq;
1083 req = tevent_req_create(mem_ctx, &state,
1084 struct smbd_smb2_logoff_state);
1088 state->smb2req = smb2req;
1090 subreq = smb2srv_session_shutdown_send(state, ev,
1093 if (tevent_req_nomem(subreq, req)) {
1094 return tevent_req_post(req, ev);
1096 tevent_req_set_callback(subreq, smbd_smb2_logoff_shutdown_done, req);
1101 static void smbd_smb2_logoff_shutdown_done(struct tevent_req *subreq)
1103 struct tevent_req *req = tevent_req_callback_data(
1104 subreq, struct tevent_req);
1105 struct smbd_smb2_logoff_state *state = tevent_req_data(
1106 req, struct smbd_smb2_logoff_state);
1109 status = smb2srv_session_shutdown_recv(subreq);
1110 if (tevent_req_nterror(req, status)) {
1113 TALLOC_FREE(subreq);
1116 * As we've been awoken, we may have changed
1117 * uid in the meantime. Ensure we're still
1118 * root (SMB2_OP_LOGOFF has .as_root = true).
1120 change_to_root_user();
1122 status = smbXsrv_session_logoff(state->smb2req->session);
1123 if (tevent_req_nterror(req, status)) {
1128 * we may need to sign the response, so we need to keep
1129 * the session until the response is sent to the wire.
1131 talloc_steal(state->smb2req, state->smb2req->session);
1133 tevent_req_done(req);
1136 static NTSTATUS smbd_smb2_logoff_recv(struct tevent_req *req)
1138 return tevent_req_simple_recv_ntstatus(req);