source4/libcli/smb2/session.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    SMB2 client session handling
   5
   6    Copyright (C) Andrew Tridgell 2005
   7
   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.
  12
  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.
  17
  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/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "system/network.h"
  24 #include <tevent.h>
  25 #include "lib/util/tevent_ntstatus.h"
  26 #include "libcli/raw/libcliraw.h"
  27 #include "libcli/smb2/smb2.h"
  28 #include "libcli/smb2/smb2_calls.h"
  29 #include "auth/gensec/gensec.h"
  30 #include "../libcli/smb/smbXcli_base.h"
  31 #include "../source3/libsmb/smb2cli.h"
  32
  33 /**
  34   initialise a smb2_session structure
  35  */
  36 struct smb2_session *smb2_session_init(struct smb2_transport *transport,
  37                                        struct gensec_settings *settings,
  38                                        TALLOC_CTX *parent_ctx, bool primary)
  39 {
  40         struct smb2_session *session;
  41         NTSTATUS status;
  42
  43         session = talloc_zero(parent_ctx, struct smb2_session);
  44         if (!session) {
  45                 return NULL;
  46         }
  47         if (primary) {
  48                 session->transport = talloc_steal(session, transport);
  49         } else {
  50                 session->transport = talloc_reference(session, transport);
  51         }
  52
  53         session->pid = getpid();
  54
  55         session->smbXcli = smbXcli_session_create(session, transport->conn);
  56         if (session->smbXcli == NULL) {
  57                 talloc_free(session);
  58                 return NULL;
  59         }
  60
  61         /* prepare a gensec context for later use */
  62         status = gensec_client_start(session, &session->gensec,
  63                                      settings);
  64         if (!NT_STATUS_IS_OK(status)) {
  65                 talloc_free(session);
  66                 return NULL;
  67         }
  68
  69         gensec_want_feature(session->gensec, GENSEC_FEATURE_SESSION_KEY);
  70
  71         return session;
  72 }
  73
  74 struct smb2_session_setup_spnego_state {
  75         struct tevent_context *ev;
  76         struct smb2_session *session;
  77         struct cli_credentials *credentials;
  78         uint64_t previous_session_id;
  79         NTSTATUS gensec_status;
  80         DATA_BLOB in_secblob;
  81         DATA_BLOB out_secblob;
  82 };
  83
  84 static void smb2_session_setup_spnego_done(struct tevent_req *subreq);
  85
  86 /*
  87   a composite function that does a full SPNEGO session setup
  88  */
  89 struct tevent_req *smb2_session_setup_spnego_send(
  90                                 TALLOC_CTX *mem_ctx,
  91                                 struct tevent_context *ev,
  92                                 struct smb2_session *session,
  93                                 struct cli_credentials *credentials,
  94                                 uint64_t previous_session_id)
  95 {
  96         struct tevent_req *req;
  97         struct smb2_session_setup_spnego_state *state;
  98         const char *chosen_oid;
  99         struct tevent_req *subreq;
 100         NTSTATUS status;
 101         const DATA_BLOB *server_gss_blob;
 102         DATA_BLOB negprot_secblob = data_blob_null;
 103         uint32_t timeout_msec;
 104
 105         timeout_msec = session->transport->options.request_timeout * 1000;
 106
 107         req = tevent_req_create(mem_ctx, &state,
 108                                 struct smb2_session_setup_spnego_state);
 109         if (req == NULL) {
 110                 return NULL;
 111         }
 112         state->ev = ev;
 113         state->session = session;
 114         state->credentials = credentials;
 115         state->previous_session_id = previous_session_id;
 116
 117         server_gss_blob = smbXcli_conn_server_gss_blob(session->transport->conn);
 118         if (server_gss_blob) {
 119                 negprot_secblob = *server_gss_blob;
 120         }
 121
 122         status = gensec_set_credentials(session->gensec, credentials);
 123         if (tevent_req_nterror(req, status)) {
 124                 return tevent_req_post(req, ev);
 125         }
 126
 127         status = gensec_set_target_hostname(session->gensec,
 128                                             smbXcli_conn_remote_name(session->transport->conn));
 129         if (tevent_req_nterror(req, status)) {
 130                 return tevent_req_post(req, ev);
 131         }
 132
 133         status = gensec_set_target_service(session->gensec, "cifs");
 134         if (tevent_req_nterror(req, status)) {
 135                 return tevent_req_post(req, ev);
 136         }
 137
 138         if (negprot_secblob.length > 0) {
 139                 chosen_oid = GENSEC_OID_SPNEGO;
 140         } else {
 141                 chosen_oid = GENSEC_OID_NTLMSSP;
 142         }
 143
 144         status = gensec_start_mech_by_oid(session->gensec, chosen_oid);
 145         if (tevent_req_nterror(req, status)) {
 146                 return tevent_req_post(req, ev);
 147         }
 148
 149         status = gensec_update(session->gensec, state,
 150                                state->ev,
 151                                negprot_secblob,
 152                                &state->in_secblob);
 153         if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 154                 tevent_req_nterror(req, status);
 155                 return tevent_req_post(req, ev);
 156         }
 157         state->gensec_status = status;
 158
 159         subreq = smb2cli_session_setup_send(state, state->ev,
 160                                             session->transport->conn,
 161                                             timeout_msec,
 162                                             session->smbXcli,
 163                                             0, /* in_flags */
 164                                             0, /* in_capabilities */
 165                                             0, /* in_channel */
 166                                             state->previous_session_id,
 167                                             &state->in_secblob);
 168         if (tevent_req_nomem(subreq, req)) {
 169                 return tevent_req_post(req, ev);
 170         }
 171         tevent_req_set_callback(subreq, smb2_session_setup_spnego_done, req);
 172
 173         return req;
 174 }
 175
 176 /*
 177   handle continuations of the spnego session setup
 178 */
 179 static void smb2_session_setup_spnego_done(struct tevent_req *subreq)
 180 {
 181         struct tevent_req *req =
 182                 tevent_req_callback_data(subreq,
 183                 struct tevent_req);
 184         struct smb2_session_setup_spnego_state *state =
 185                 tevent_req_data(req,
 186                 struct smb2_session_setup_spnego_state);
 187         struct smb2_session *session = state->session;
 188         NTSTATUS peer_status;
 189         NTSTATUS status;
 190         struct iovec *recv_iov;
 191         uint32_t timeout_msec;
 192
 193         timeout_msec = session->transport->options.request_timeout * 1000;
 194
 195         status = smb2cli_session_setup_recv(subreq, state,
 196                                             &recv_iov,
 197                                             &state->out_secblob);
 198         if (!NT_STATUS_IS_OK(status) &&
 199             !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 200                 tevent_req_nterror(req, status);
 201                 return;
 202         }
 203         peer_status = status;
 204
 205         if (NT_STATUS_EQUAL(state->gensec_status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 206                 status = gensec_update(session->gensec, state,
 207                                        state->ev,
 208                                        state->out_secblob,
 209                                        &state->in_secblob);
 210                 state->gensec_status = status;
 211         }
 212
 213         if (!NT_STATUS_IS_OK(status) &&
 214             !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 215                 tevent_req_nterror(req, status);
 216                 return;
 217         }
 218
 219         if (NT_STATUS_IS_OK(peer_status) && NT_STATUS_IS_OK(state->gensec_status)) {
 220                 DATA_BLOB session_key;
 221
 222                 status = gensec_session_key(session->gensec, state,
 223                                             &session_key);
 224                 if (tevent_req_nterror(req, status)) {
 225                         return;
 226                 }
 227
 228                 status = smb2cli_session_set_session_key(session->smbXcli,
 229                                                          session_key,
 230                                                          recv_iov);
 231                 if (tevent_req_nterror(req, status)) {
 232                         return;
 233                 }
 234
 235                 tevent_req_done(req);
 236                 return;
 237         }
 238
 239         subreq = smb2cli_session_setup_send(state, state->ev,
 240                                             session->transport->conn,
 241                                             timeout_msec,
 242                                             session->smbXcli,
 243                                             0, /* in_flags */
 244                                             0, /* in_capabilities */
 245                                             0, /* in_channel */
 246                                             state->previous_session_id,
 247                                             &state->in_secblob);
 248         if (tevent_req_nomem(subreq, req)) {
 249                 return;
 250         }
 251         tevent_req_set_callback(subreq, smb2_session_setup_spnego_done, req);
 252 }
 253
 254 /*
 255   receive a composite session setup reply
 256 */
 257 NTSTATUS smb2_session_setup_spnego_recv(struct tevent_req *req)
 258 {
 259         return tevent_req_simple_recv_ntstatus(req);
 260 }
 261
 262 /*
 263   sync version of smb2_session_setup_spnego
 264 */
 265 NTSTATUS smb2_session_setup_spnego(struct smb2_session *session,
 266                                    struct cli_credentials *credentials,
 267                                    uint64_t previous_session_id)
 268 {
 269         struct tevent_req *subreq;
 270         NTSTATUS status;
 271         bool ok;
 272         TALLOC_CTX *frame = talloc_stackframe();
 273         struct tevent_context *ev = session->transport->ev;
 274
 275         if (frame == NULL) {
 276                 return NT_STATUS_NO_MEMORY;
 277         }
 278
 279         subreq = smb2_session_setup_spnego_send(frame, ev,
 280                                                 session, credentials,
 281                                                 previous_session_id);
 282         if (subreq == NULL) {
 283                 TALLOC_FREE(frame);
 284                 return NT_STATUS_NO_MEMORY;
 285         }
 286
 287         ok = tevent_req_poll(subreq, ev);
 288         if (!ok) {
 289                 status = map_nt_error_from_unix_common(errno);
 290                 TALLOC_FREE(frame);
 291                 return status;
 292         }
 293
 294         status = smb2_session_setup_spnego_recv(subreq);
 295         TALLOC_FREE(subreq);
 296         if (!NT_STATUS_IS_OK(status)) {
 297                 TALLOC_FREE(frame);
 298                 return status;
 299         }
 300
 301         TALLOC_FREE(frame);
 302         return NT_STATUS_OK;
 303 }