source4/auth/gensec/schannel_state.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    module to store/fetch session keys for the schannel server
   5
   6    Copyright (C) Andrew Tridgell 2004
   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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "lib/ldb/include/ldb.h"
  25 #include "lib/ldb/include/ldb_errors.h"
  26 #include "dsdb/samdb/samdb.h"
  27 #include "db_wrap.h"
  28 #include "libcli/auth/libcli_auth.h"
  29 #include "auth/auth.h"
  30
  31 /**
  32   connect to the schannel ldb
  33 */
  34 struct ldb_context *schannel_db_connect(TALLOC_CTX *mem_ctx)
  35 {
  36         char *path;
  37         struct ldb_context *ldb;
  38         BOOL existed;
  39         const char *init_ldif =
  40                 "dn: @ATTRIBUTES\n" \
  41                 "computerName: CASE_INSENSITIVE\n" \
  42                 "flatname: CASE_INSENSITIVE\n";
  43
  44         path = smbd_tmp_path(mem_ctx, "schannel.ldb");
  45         if (!path) {
  46                 return NULL;
  47         }
  48
  49         existed = file_exist(path);
  50
  51         ldb = ldb_wrap_connect(mem_ctx, path, system_session(mem_ctx),
  52                                NULL, LDB_FLG_NOSYNC, NULL);
  53         talloc_free(path);
  54         if (!ldb) {
  55                 return NULL;
  56         }
  57
  58         if (!existed) {
  59                 gendb_add_ldif(ldb, init_ldif);
  60         }
  61
  62         return ldb;
  63 }
  64
  65 /*
  66   remember an established session key for a netr server authentication
  67   use a simple ldb structure
  68 */
  69 NTSTATUS schannel_store_session_key_ldb(TALLOC_CTX *mem_ctx,
  70                                         struct ldb_context *ldb,
  71                                         struct creds_CredentialState *creds)
  72 {
  73         struct ldb_message *msg;
  74         struct ldb_val val, seed, client_state, server_state;
  75         char *f;
  76         char *sct;
  77         int ret;
  78
  79         f = talloc_asprintf(mem_ctx, "%u", (unsigned int)creds->negotiate_flags);
  80
  81         if (f == NULL) {
  82                 return NT_STATUS_NO_MEMORY;
  83         }
  84
  85         sct = talloc_asprintf(mem_ctx, "%u", (unsigned int)creds->secure_channel_type);
  86
  87         if (sct == NULL) {
  88                 return NT_STATUS_NO_MEMORY;
  89         }
  90
  91         msg = ldb_msg_new(ldb);
  92         if (msg == NULL) {
  93                 return NT_STATUS_NO_MEMORY;
  94         }
  95
  96         msg->dn = ldb_dn_new_fmt(msg, ldb, "computerName=%s", creds->computer_name);
  97         if ( ! msg->dn) {
  98                 return NT_STATUS_NO_MEMORY;
  99         }
 100
 101         val.data = creds->session_key;
 102         val.length = sizeof(creds->session_key);
 103
 104         seed.data = creds->seed.data;
 105         seed.length = sizeof(creds->seed.data);
 106
 107         client_state.data = creds->client.data;
 108         client_state.length = sizeof(creds->client.data);
 109         server_state.data = creds->server.data;
 110         server_state.length = sizeof(creds->server.data);
 111
 112         ldb_msg_add_string(msg, "objectClass", "schannelState");
 113         ldb_msg_add_value(msg, "sessionKey", &val, NULL);
 114         ldb_msg_add_value(msg, "seed", &seed, NULL);
 115         ldb_msg_add_value(msg, "clientState", &client_state, NULL);
 116         ldb_msg_add_value(msg, "serverState", &server_state, NULL);
 117         ldb_msg_add_string(msg, "negotiateFlags", f);
 118         ldb_msg_add_string(msg, "secureChannelType", sct);
 119         ldb_msg_add_string(msg, "accountName", creds->account_name);
 120         ldb_msg_add_string(msg, "computerName", creds->computer_name);
 121         ldb_msg_add_string(msg, "flatname", creds->domain);
 122         samdb_msg_add_dom_sid(ldb, mem_ctx, msg, "objectSid", creds->sid);
 123
 124         ldb_delete(ldb, msg->dn);
 125
 126         ret = ldb_add(ldb, msg);
 127
 128         if (ret != 0) {
 129                 DEBUG(0,("Unable to add %s to session key db - %s\n",
 130                          ldb_dn_get_linearized(msg->dn), ldb_errstring(ldb)));
 131                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 132         }
 133
 134         return NT_STATUS_OK;
 135 }
 136
 137 NTSTATUS schannel_store_session_key(TALLOC_CTX *mem_ctx,
 138                                     struct creds_CredentialState *creds)
 139 {
 140         struct ldb_context *ldb;
 141         NTSTATUS nt_status;
 142         int ret;
 143
 144         ldb = schannel_db_connect(mem_ctx);
 145         if (!ldb) {
 146                 return NT_STATUS_ACCESS_DENIED;
 147         }
 148
 149         ret = ldb_transaction_start(ldb);
 150         if (ret != 0) {
 151                 talloc_free(ldb);
 152                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 153         }
 154
 155         nt_status = schannel_store_session_key_ldb(mem_ctx, ldb, creds);
 156
 157         if (NT_STATUS_IS_OK(nt_status)) {
 158                 ret = ldb_transaction_commit(ldb);
 159         } else {
 160                 ret = ldb_transaction_cancel(ldb);
 161         }
 162
 163         if (ret != 0) {
 164                 DEBUG(0,("Unable to commit adding credentials for %s to schannel key db - %s\n",
 165                          creds->computer_name, ldb_errstring(ldb)));
 166                 talloc_free(ldb);
 167                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 168         }
 169
 170         talloc_free(ldb);
 171         return nt_status;
 172 }
 173
 174 /*
 175   read back a credentials back for a computer
 176 */
 177 NTSTATUS schannel_fetch_session_key_ldb(TALLOC_CTX *mem_ctx,
 178                                         struct ldb_context *ldb,
 179                                         const char *computer_name,
 180                                         const char *domain,
 181                                         struct creds_CredentialState **creds)
 182 {
 183         struct ldb_result *res;
 184         int ret;
 185         const struct ldb_val *val;
 186         char *expr=NULL;
 187
 188         *creds = talloc_zero(mem_ctx, struct creds_CredentialState);
 189         if (!*creds) {
 190                 return NT_STATUS_NO_MEMORY;
 191         }
 192
 193         expr = talloc_asprintf(mem_ctx, "(&(computerName=%s)(flatname=%s))",
 194                                computer_name, domain);
 195         if (expr == NULL) {
 196                 return NT_STATUS_NO_MEMORY;
 197         }
 198
 199         ret = ldb_search(ldb, NULL, LDB_SCOPE_SUBTREE, expr, NULL, &res);
 200         talloc_free(expr);
 201         if (ret != LDB_SUCCESS) {
 202                 DEBUG(3,("schannel: Failed to find a record for client %s: %s\n", computer_name, ldb_errstring(ldb)));
 203                 talloc_free(res);
 204                 return NT_STATUS_INVALID_HANDLE;
 205         }
 206         talloc_steal(mem_ctx, res);
 207         if (res->count != 1) {
 208                 DEBUG(3,("schannel: Failed to find a record for client: %s (found %d records)\n", computer_name, res->count));
 209                 talloc_free(res);
 210                 return NT_STATUS_INVALID_HANDLE;
 211         }
 212
 213         val = ldb_msg_find_ldb_val(res->msgs[0], "sessionKey");
 214         if (val == NULL || val->length != 16) {
 215                 DEBUG(1,("schannel: record in schannel DB must contain a sessionKey of length 16, when searching for client: %s\n", computer_name));
 216                 talloc_free(res);
 217                 return NT_STATUS_INTERNAL_ERROR;
 218         }
 219
 220         memcpy((*creds)->session_key, val->data, 16);
 221
 222         val = ldb_msg_find_ldb_val(res->msgs[0], "seed");
 223         if (val == NULL || val->length != 8) {
 224                 DEBUG(1,("schannel: record in schannel DB must contain a vaid seed of length 8, when searching for client: %s\n", computer_name));
 225                 talloc_free(res);
 226                 return NT_STATUS_INTERNAL_ERROR;
 227         }
 228
 229         memcpy((*creds)->seed.data, val->data, 8);
 230
 231         val = ldb_msg_find_ldb_val(res->msgs[0], "clientState");
 232         if (val == NULL || val->length != 8) {
 233                 DEBUG(1,("schannel: record in schannel DB must contain a vaid clientState of length 8, when searching for client: %s\n", computer_name));
 234                 talloc_free(res);
 235                 return NT_STATUS_INTERNAL_ERROR;
 236         }
 237         memcpy((*creds)->client.data, val->data, 8);
 238
 239         val = ldb_msg_find_ldb_val(res->msgs[0], "serverState");
 240         if (val == NULL || val->length != 8) {
 241                 DEBUG(1,("schannel: record in schannel DB must contain a vaid serverState of length 8, when searching for client: %s\n", computer_name));
 242                 talloc_free(res);
 243                 return NT_STATUS_INTERNAL_ERROR;
 244         }
 245         memcpy((*creds)->server.data, val->data, 8);
 246
 247         (*creds)->negotiate_flags = ldb_msg_find_attr_as_int(res->msgs[0], "negotiateFlags", 0);
 248
 249         (*creds)->secure_channel_type = ldb_msg_find_attr_as_int(res->msgs[0], "secureChannelType", 0);
 250
 251         (*creds)->account_name = talloc_strdup(*creds, ldb_msg_find_attr_as_string(res->msgs[0], "accountName", NULL));
 252         if ((*creds)->account_name == NULL) {
 253                 talloc_free(res);
 254                 return NT_STATUS_NO_MEMORY;
 255         }
 256
 257         (*creds)->computer_name = talloc_strdup(*creds, ldb_msg_find_attr_as_string(res->msgs[0], "computerName", NULL));
 258         if ((*creds)->computer_name == NULL) {
 259                 talloc_free(res);
 260                 return NT_STATUS_NO_MEMORY;
 261         }
 262
 263         (*creds)->domain = talloc_strdup(*creds, ldb_msg_find_attr_as_string(res->msgs[0], "flatname", NULL));
 264         if ((*creds)->domain == NULL) {
 265                 talloc_free(res);
 266                 return NT_STATUS_NO_MEMORY;
 267         }
 268
 269         (*creds)->sid = samdb_result_dom_sid(*creds, res->msgs[0], "objectSid");
 270
 271         talloc_free(res);
 272         return NT_STATUS_OK;
 273 }
 274
 275 NTSTATUS schannel_fetch_session_key(TALLOC_CTX *mem_ctx,
 276                                         const char *computer_name,
 277                                         const char *domain,
 278                                         struct creds_CredentialState **creds)
 279 {
 280         NTSTATUS nt_status;
 281         struct ldb_context *ldb;
 282
 283         ldb = schannel_db_connect(mem_ctx);
 284         if (!ldb) {
 285                 return NT_STATUS_ACCESS_DENIED;
 286         }
 287
 288         nt_status = schannel_fetch_session_key_ldb(mem_ctx, ldb,
 289                                                    computer_name, domain,
 290                                                    creds);
 291         talloc_free(ldb);
 292         return nt_status;
 293 }