source/auth/auth.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Password and authentication handling
   4    Copyright (C) Andrew Bartlett         2001-2002
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 #undef DBGC_CLASS
  24 #define DBGC_CLASS DBGC_AUTH
  25
  26 /****************************************************************************
  27  Try to get a challenge out of the various authentication modules.
  28  Returns a const char of length 8 bytes.
  29 ****************************************************************************/
  30
  31 static const uint8_t *get_ntlm_challenge(struct auth_context *auth_context)
  32 {
  33         DATA_BLOB challenge = data_blob(NULL, 0);
  34         const char *challenge_set_by = NULL;
  35         struct auth_methods *auth_method;
  36         TALLOC_CTX *mem_ctx;
  37
  38         if (auth_context->challenge.length) {
  39                 DEBUG(5, ("get_ntlm_challenge (auth subsystem): returning previous challenge by module %s (normal)\n",
  40                           auth_context->challenge_set_by));
  41                 return auth_context->challenge.data;
  42         }
  43
  44         auth_context->challenge_may_be_modified = False;
  45
  46         for (auth_method = auth_context->auth_method_list; auth_method; auth_method = auth_method->next) {
  47                 if (auth_method->get_chal == NULL) {
  48                         DEBUG(5, ("auth_get_challenge: module %s did not want to specify a challenge\n", auth_method->name));
  49                         continue;
  50                 }
  51
  52                 DEBUG(5, ("auth_get_challenge: getting challenge from module %s\n", auth_method->name));
  53                 if (challenge_set_by != NULL) {
  54                         DEBUG(1, ("auth_get_challenge: CONFIGURATION ERROR: authentication method %s has already specified a challenge.  Challenge by %s ignored.\n",
  55                                   challenge_set_by, auth_method->name));
  56                         continue;
  57                 }
  58
  59                 mem_ctx = talloc_init("auth_get_challenge for module %s", auth_method->name);
  60                 if (!mem_ctx) {
  61                         smb_panic("talloc_init() failed!");
  62                 }
  63
  64                 challenge = auth_method->get_chal(auth_context, &auth_method->private_data, mem_ctx);
  65                 if (!challenge.length) {
  66                         DEBUG(3, ("auth_get_challenge: getting challenge from authentication method %s FAILED.\n",
  67                                   auth_method->name));
  68                 } else {
  69                         DEBUG(5, ("auth_get_challenge: sucessfully got challenge from module %s\n", auth_method->name));
  70                         auth_context->challenge = challenge;
  71                         challenge_set_by = auth_method->name;
  72                         auth_context->challenge_set_method = auth_method;
  73                 }
  74                 talloc_destroy(mem_ctx);
  75         }
  76
  77         if (!challenge_set_by) {
  78                 uint8_t chal[8];
  79
  80                 generate_random_buffer(chal, sizeof(chal), False);
  81                 auth_context->challenge = data_blob_talloc(auth_context->mem_ctx,
  82                                                            chal, sizeof(chal));
  83
  84                 challenge_set_by = "random";
  85                 auth_context->challenge_may_be_modified = True;
  86         }
  87
  88         DEBUG(5, ("auth_context challenge created by %s\n", challenge_set_by));
  89         DEBUG(5, ("challenge is: \n"));
  90         dump_data(5, (const char *)auth_context->challenge.data, auth_context->challenge.length);
  91
  92         SMB_ASSERT(auth_context->challenge.length == 8);
  93
  94         auth_context->challenge_set_by=challenge_set_by;
  95
  96         return auth_context->challenge.data;
  97 }
  98
  99
 100 /**
 101  * Check user is in correct domain (if required)
 102  *
 103  * @param user Only used to fill in the debug message
 104  *
 105  * @param domain The domain to be verified
 106  *
 107  * @return True if the user can connect with that domain,
 108  *         False otherwise.
 109 **/
 110
 111 static BOOL check_domain_match(const char *user, const char *domain)
 112 {
 113         /*
 114          * If we aren't serving to trusted domains, we must make sure that
 115          * the validation request comes from an account in the same domain
 116          * as the Samba server
 117          */
 118
 119         if (!lp_allow_trusted_domains() &&
 120             !(strequal("", domain) ||
 121               strequal(lp_workgroup(), domain) ||
 122               is_myname(domain))) {
 123                 DEBUG(1, ("check_domain_match: Attempt to connect as user %s from domain %s denied.\n", user, domain));
 124                 return False;
 125         } else {
 126                 return True;
 127         }
 128 }
 129
 130 /**
 131  * Check a user's Plaintext, LM or NTLM password.
 132  *
 133  * Check a user's password, as given in the user_info struct and return various
 134  * interesting details in the server_info struct.
 135  *
 136  * The return value takes precedence over the contents of the server_info
 137  * struct.  When the return is other than NT_STATUS_OK the contents
 138  * of that structure is undefined.
 139  *
 140  * @param user_info Contains the user supplied components, including the passwords.
 141  *                  Must be created with make_user_info() or one of its wrappers.
 142  *
 143  * @param auth_context Supplies the challenges and some other data.
 144  *                  Must be created with make_auth_context(), and the challenges should be
 145  *                  filled in, either at creation or by calling the challenge geneation
 146  *                  function auth_get_challenge().
 147  *
 148  * @param server_info If successful, contains information about the authentication,
 149  *                    including a SAM_ACCOUNT struct describing the user.
 150  *
 151  * @return An NTSTATUS with NT_STATUS_OK or an appropriate error.
 152  *
 153  **/
 154
 155 static NTSTATUS check_ntlm_password(const struct auth_context *auth_context,
 156                                     const struct auth_usersupplied_info *user_info,
 157                                     struct auth_serversupplied_info **server_info)
 158 {
 159         /* if all the modules say 'not for me' this is reasonable */
 160         NTSTATUS nt_status = NT_STATUS_NO_SUCH_USER;
 161         struct auth_methods *auth_method;
 162         TALLOC_CTX *mem_ctx;
 163
 164         if (!user_info || !auth_context || !server_info)
 165                 return NT_STATUS_LOGON_FAILURE;
 166
 167         DEBUG(3, ("check_ntlm_password:  Checking password for unmapped user [%s]\\[%s]@[%s] with the new password interface\n",
 168                   user_info->client_domain.str, user_info->smb_name.str, user_info->wksta_name.str));
 169
 170         DEBUG(3, ("check_ntlm_password:  mapped user is: [%s]\\[%s]@[%s]\n",
 171                   user_info->domain.str, user_info->internal_username.str, user_info->wksta_name.str));
 172
 173         if (auth_context->challenge.length == 0) {
 174                 /* get a challenge, if we have not asked for one yet */
 175                 get_ntlm_challenge(auth_context);
 176         }
 177
 178         if (auth_context->challenge.length != 8) {
 179                 DEBUG(0, ("check_ntlm_password:  Invalid challenge stored for this auth context - cannot continue\n"));
 180                 return NT_STATUS_LOGON_FAILURE;
 181         }
 182
 183         if (auth_context->challenge_set_by)
 184                 DEBUG(10, ("check_ntlm_password: auth_context challenge created by %s\n",
 185                                         auth_context->challenge_set_by));
 186
 187         DEBUG(10, ("challenge is: \n"));
 188         dump_data(5, (const char *)auth_context->challenge.data, auth_context->challenge.length);
 189
 190 #ifdef DEBUG_PASSWORD
 191         DEBUG(100, ("user_info has passwords of length %d and %d\n",
 192                     user_info->lm_resp.length, user_info->nt_resp.length));
 193         DEBUG(100, ("lm:\n"));
 194         dump_data(100, user_info->lm_resp.data, user_info->lm_resp.length);
 195         DEBUG(100, ("nt:\n"));
 196         dump_data(100, user_info->nt_resp.data, user_info->nt_resp.length);
 197 #endif
 198
 199         /* This needs to be sorted:  If it doesn't match, what should we do? */
 200         if (!check_domain_match(user_info->smb_name.str, user_info->domain.str))
 201                 return NT_STATUS_LOGON_FAILURE;
 202
 203         for (auth_method = auth_context->auth_method_list;auth_method; auth_method = auth_method->next) {
 204                 NTSTATUS result;
 205
 206                 mem_ctx = talloc_init("%s authentication for user %s\\%s", auth_method->name,
 207                                             user_info->domain.str, user_info->smb_name.str);
 208
 209                 result = auth_method->auth(auth_context, auth_method->private_data, mem_ctx, user_info, server_info);
 210
 211                 /* check if the module did anything */
 212                 if ( NT_STATUS_V(result) == NT_STATUS_V(NT_STATUS_NOT_IMPLEMENTED) ) {
 213                         DEBUG(10,("check_ntlm_password: %s had nothing to say\n", auth_method->name));
 214                         talloc_destroy(mem_ctx);
 215                         continue;
 216                 }
 217
 218                 nt_status = result;
 219
 220                 if (NT_STATUS_IS_OK(nt_status)) {
 221                         DEBUG(3, ("check_ntlm_password: %s authentication for user [%s] succeeded\n",
 222                                   auth_method->name, user_info->smb_name.str));
 223                 } else {
 224                         DEBUG(5, ("check_ntlm_password: %s authentication for user [%s] FAILED with error %s\n",
 225                                   auth_method->name, user_info->smb_name.str, nt_errstr(nt_status)));
 226                 }
 227
 228                 talloc_destroy(mem_ctx);
 229
 230                 if ( NT_STATUS_IS_OK(nt_status))
 231                 {
 232                                 break;
 233                 }
 234         }
 235
 236         if (NT_STATUS_IS_OK(nt_status)) {
 237                 if (NT_STATUS_IS_OK(nt_status)) {
 238                         DEBUG((*server_info)->guest ? 5 : 2,
 239                               ("check_ntlm_password:  %sauthentication for user [%s] -> [%s] succeeded\n",
 240                                (*server_info)->guest ? "guest " : "",
 241                                user_info->smb_name.str,
 242                                user_info->internal_username.str));
 243                 }
 244         }
 245
 246         if (!NT_STATUS_IS_OK(nt_status)) {
 247                 DEBUG(2, ("check_ntlm_password:  Authentication for user [%s] -> [%s] FAILED with error %s\n",
 248                           user_info->smb_name.str, user_info->internal_username.str,
 249                           nt_errstr(nt_status)));
 250                 ZERO_STRUCTP(server_info);
 251         }
 252         return nt_status;
 253 }
 254
 255 /***************************************************************************
 256  Clear out a auth_context, and destroy the attached TALLOC_CTX
 257 ***************************************************************************/
 258
 259 void free_auth_context(struct auth_context **auth_context)
 260 {
 261         struct auth_methods *auth_method;
 262
 263         if (*auth_context) {
 264                 /* Free private data of context's authentication methods */
 265                 for (auth_method = (*auth_context)->auth_method_list; auth_method; auth_method = auth_method->next) {
 266                         if (auth_method->free_private_data) {
 267                                 auth_method->free_private_data (&auth_method->private_data);
 268                                 auth_method->private_data = NULL;
 269                         }
 270                 }
 271
 272                 talloc_destroy((*auth_context)->mem_ctx);
 273                 *auth_context = NULL;
 274         }
 275 }
 276
 277 /***************************************************************************
 278  Make a auth_info struct
 279 ***************************************************************************/
 280
 281 static NTSTATUS make_auth_context(struct auth_context **auth_context)
 282 {
 283         TALLOC_CTX *mem_ctx;
 284
 285         mem_ctx = talloc_init("authentication context");
 286
 287         *auth_context = talloc(mem_ctx, sizeof(**auth_context));
 288         if (!*auth_context) {
 289                 DEBUG(0,("make_auth_context: talloc failed!\n"));
 290                 talloc_destroy(mem_ctx);
 291                 return NT_STATUS_NO_MEMORY;
 292         }
 293         ZERO_STRUCTP(*auth_context);
 294
 295         (*auth_context)->mem_ctx = mem_ctx;
 296         (*auth_context)->check_ntlm_password = check_ntlm_password;
 297         (*auth_context)->get_ntlm_challenge = get_ntlm_challenge;
 298
 299         return NT_STATUS_OK;
 300 }
 301
 302 /***************************************************************************
 303  Make a auth_info struct for the auth subsystem
 304 ***************************************************************************/
 305
 306 static NTSTATUS make_auth_context_text_list(struct auth_context **auth_context, char **text_list)
 307 {
 308         struct auth_methods *list = NULL;
 309         struct auth_methods *t = NULL;
 310         int i;
 311         NTSTATUS nt_status;
 312
 313         if (!text_list) {
 314                 DEBUG(2,("make_auth_context_text_list: No auth method list!?\n"));
 315                 return NT_STATUS_UNSUCCESSFUL;
 316         }
 317
 318         if (!NT_STATUS_IS_OK(nt_status = make_auth_context(auth_context)))
 319                 return nt_status;
 320
 321         for (;*text_list; text_list++) {
 322                 char *module_name = smb_xstrdup(*text_list);
 323                 char *module_params = NULL;
 324                 char *p;
 325                 const struct auth_operations *ops;
 326
 327                 DEBUG(5,("make_auth_context_text_list: Attempting to find an auth method to match %s\n",
 328                                         *text_list));
 329
 330                 p = strchr(module_name, ':');
 331                 if (p) {
 332                         *p = 0;
 333                         module_params = p+1;
 334                         trim_string(module_params, " ", " ");
 335                 }
 336
 337                 trim_string(module_name, " ", " ");
 338
 339                 ops = auth_backend_byname(module_name);
 340                 if (!ops) {
 341                         DEBUG(5,("make_auth_context_text_list: Found auth method %s (at pos %d)\n", *text_list, i));
 342                         SAFE_FREE(module_name);
 343                         break;
 344                 }
 345
 346                 if (NT_STATUS_IS_OK(ops->init(*auth_context, module_params, &t))) {
 347                         DEBUG(5,("make_auth_context_text_list: auth method %s has a valid init\n",
 348                                                 *text_list));
 349                         DLIST_ADD_END(list, t, struct auth_methods *);
 350                 } else {
 351                         DEBUG(0,("make_auth_context_text_list: auth method %s did not correctly init\n",
 352                                                 *text_list));
 353                 }
 354                 SAFE_FREE(module_name);
 355         }
 356
 357         (*auth_context)->auth_method_list = list;
 358
 359         return nt_status;
 360 }
 361
 362 /***************************************************************************
 363  Make a auth_context struct for the auth subsystem
 364 ***************************************************************************/
 365
 366 NTSTATUS make_auth_context_subsystem(struct auth_context **auth_context)
 367 {
 368         char **auth_method_list = NULL;
 369         NTSTATUS nt_status;
 370
 371         if (lp_auth_methods() && !str_list_copy(&auth_method_list, lp_auth_methods())) {
 372                 return NT_STATUS_NO_MEMORY;
 373         }
 374
 375         if (!NT_STATUS_IS_OK(nt_status = make_auth_context_text_list(auth_context, auth_method_list))) {
 376                 str_list_free(&auth_method_list);
 377                 return nt_status;
 378         }
 379
 380         str_list_free(&auth_method_list);
 381         return nt_status;
 382 }
 383
 384 /***************************************************************************
 385  Make a auth_info struct with a fixed challenge
 386 ***************************************************************************/
 387
 388 NTSTATUS make_auth_context_fixed(struct auth_context **auth_context, uint8_t chal[8])
 389 {
 390         NTSTATUS nt_status;
 391         if (!NT_STATUS_IS_OK(nt_status = make_auth_context_subsystem(auth_context))) {
 392                 return nt_status;
 393         }
 394
 395         (*auth_context)->challenge = data_blob_talloc((*auth_context)->mem_ctx, chal, 8);
 396         (*auth_context)->challenge_set_by = "fixed";
 397         return nt_status;
 398 }
 399
 400 /* the list of currently registered AUTH backends */
 401 static struct {
 402         const struct auth_operations *ops;
 403 } *backends = NULL;
 404 static int num_backends;
 405
 406 /*
 407   register a AUTH backend.
 408
 409   The 'name' can be later used by other backends to find the operations
 410   structure for this backend.
 411 */
 412 static NTSTATUS auth_register(void *_ops)
 413 {
 414         const struct auth_operations *ops = _ops;
 415         struct auth_operations *new_ops;
 416
 417         if (auth_backend_byname(ops->name) != NULL) {
 418                 /* its already registered! */
 419                 DEBUG(0,("AUTH backend '%s' already registered\n",
 420                          ops->name));
 421                 return NT_STATUS_OBJECT_NAME_COLLISION;
 422         }
 423
 424         backends = Realloc(backends, sizeof(backends[0]) * (num_backends+1));
 425         if (!backends) {
 426                 smb_panic("out of memory in auth_register");
 427         }
 428
 429         new_ops = smb_xmemdup(ops, sizeof(*ops));
 430         new_ops->name = smb_xstrdup(ops->name);
 431
 432         backends[num_backends].ops = new_ops;
 433
 434         num_backends++;
 435
 436         DEBUG(3,("AUTH backend '%s' registered\n",
 437                  ops->name));
 438
 439         return NT_STATUS_OK;
 440 }
 441
 442 /*
 443   return the operations structure for a named backend of the specified type
 444 */
 445 const struct auth_operations *auth_backend_byname(const char *name)
 446 {
 447         int i;
 448
 449         for (i=0;i<num_backends;i++) {
 450                 if (strcmp(backends[i].ops->name, name) == 0) {
 451                         return backends[i].ops;
 452                 }
 453         }
 454
 455         return NULL;
 456 }
 457
 458 /*
 459   return the AUTH interface version, and the size of some critical types
 460   This can be used by backends to either detect compilation errors, or provide
 461   multiple implementations for different smbd compilation options in one module
 462 */
 463 const struct auth_critical_sizes *auth_interface_version(void)
 464 {
 465         static const struct auth_critical_sizes critical_sizes = {
 466                 AUTH_INTERFACE_VERSION,
 467                 sizeof(struct auth_operations),
 468                 sizeof(struct auth_methods),
 469                 sizeof(struct auth_context),
 470                 sizeof(struct auth_ntlmssp_state),
 471                 sizeof(struct auth_usersupplied_info),
 472                 sizeof(struct auth_serversupplied_info),
 473                 sizeof(struct auth_str),
 474         };
 475
 476         return &critical_sizes;
 477 }
 478
 479 /*
 480   initialise the AUTH subsystem
 481 */
 482 BOOL auth_init(void)
 483 {
 484         NTSTATUS status;
 485
 486         status = register_subsystem("auth", auth_register);
 487         if (!NT_STATUS_IS_OK(status)) {
 488                 return False;
 489         }
 490
 491         /* FIXME: Perhaps panic if a basic backend, such as SAM, fails to initialise? */
 492         static_init_auth;
 493
 494         DEBUG(3,("AUTH subsystem version %d initialised\n", AUTH_INTERFACE_VERSION));
 495         return True;
 496 }