auth: Generate a human readable Authentication log message.
[nivanova/samba-autobuild/.git] / source3 / 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 3 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, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "auth.h"
22 #include "../lib/tsocket/tsocket.h"
23
24 #undef DBGC_CLASS
25 #define DBGC_CLASS DBGC_AUTH
26
27 static_decl_auth;
28
29 static struct auth_init_function_entry *auth_backends = NULL;
30
31 static struct auth_init_function_entry *auth_find_backend_entry(const char *name);
32
33 NTSTATUS smb_register_auth(int version, const char *name, auth_init_function init)
34 {
35         struct auth_init_function_entry *entry = auth_backends;
36
37         if (version != AUTH_INTERFACE_VERSION) {
38                 DEBUG(0,("Can't register auth_method!\n"
39                          "You tried to register an auth module with AUTH_INTERFACE_VERSION %d, while this version of samba uses %d\n",
40                          version,AUTH_INTERFACE_VERSION));
41                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
42         }
43
44         if (!name || !init) {
45                 return NT_STATUS_INVALID_PARAMETER;
46         }
47
48         DEBUG(5,("Attempting to register auth backend %s\n", name));
49
50         if (auth_find_backend_entry(name)) {
51                 DEBUG(0,("There already is an auth method registered with the name %s!\n", name));
52                 return NT_STATUS_OBJECT_NAME_COLLISION;
53         }
54
55         entry = SMB_XMALLOC_P(struct auth_init_function_entry);
56         entry->name = smb_xstrdup(name);
57         entry->init = init;
58
59         DLIST_ADD(auth_backends, entry);
60         DEBUG(5,("Successfully added auth method '%s'\n", name));
61         return NT_STATUS_OK;
62 }
63
64 static struct auth_init_function_entry *auth_find_backend_entry(const char *name)
65 {
66         struct auth_init_function_entry *entry = auth_backends;
67
68         while(entry) {
69                 if (strcmp(entry->name, name)==0) return entry;
70                 entry = entry->next;
71         }
72
73         return NULL;
74 }
75
76 /****************************************************************************
77  Try to get a challenge out of the various authentication modules.
78  Returns a const char of length 8 bytes.
79 ****************************************************************************/
80
81 NTSTATUS auth_get_ntlm_challenge(struct auth_context *auth_context,
82                                  uint8_t chal[8])
83 {
84         uchar tmp[8];
85
86
87         if (auth_context->challenge.length) {
88                 DEBUG(5, ("get_ntlm_challenge (auth subsystem): returning previous challenge by module %s (normal)\n", 
89                           auth_context->challenge_set_by));
90                 memcpy(chal, auth_context->challenge.data, 8);
91                 return NT_STATUS_OK;
92         }
93
94         generate_random_buffer(tmp, sizeof(tmp));
95         auth_context->challenge = data_blob_talloc(auth_context,
96                                                    tmp, sizeof(tmp));
97
98         auth_context->challenge_set_by = "random";
99
100         memcpy(chal, auth_context->challenge.data, 8);
101         return NT_STATUS_OK;
102 }
103
104
105 /**
106  * Check user is in correct domain (if required)
107  *
108  * @param user Only used to fill in the debug message
109  * 
110  * @param domain The domain to be verified
111  *
112  * @return True if the user can connect with that domain, 
113  *         False otherwise.
114 **/
115
116 static bool check_domain_match(const char *user, const char *domain) 
117 {
118         /*
119          * If we aren't serving to trusted domains, we must make sure that
120          * the validation request comes from an account in the same domain
121          * as the Samba server
122          */
123
124         if (!lp_allow_trusted_domains() &&
125             !(strequal("", domain) || 
126               strequal(lp_workgroup(), domain) || 
127               is_myname(domain))) {
128                 DEBUG(1, ("check_domain_match: Attempt to connect as user %s from domain %s denied.\n", user, domain));
129                 return False;
130         } else {
131                 return True;
132         }
133 }
134
135 /**
136  * Check a user's Plaintext, LM or NTLM password.
137  *
138  * Check a user's password, as given in the user_info struct and return various
139  * interesting details in the server_info struct.
140  *
141  * This function does NOT need to be in a become_root()/unbecome_root() pair
142  * as it makes the calls itself when needed.
143  *
144  * The return value takes precedence over the contents of the server_info 
145  * struct.  When the return is other than NT_STATUS_OK the contents 
146  * of that structure is undefined.
147  *
148  * @param user_info Contains the user supplied components, including the passwords.
149  *                  Must be created with make_user_info() or one of its wrappers.
150  *
151  * @param auth_context Supplies the challenges and some other data. 
152  *                  Must be created with make_auth_context(), and the challenges should be 
153  *                  filled in, either at creation or by calling the challenge geneation 
154  *                  function auth_get_challenge().  
155  *
156  * @param pserver_info If successful, contains information about the authentication,
157  *                     including a struct samu struct describing the user.
158  *
159  * @param pauthoritative Indicates if the result should be treated as final
160  *                       result.
161  *
162  * @return An NTSTATUS with NT_STATUS_OK or an appropriate error.
163  *
164  **/
165 NTSTATUS auth_check_ntlm_password(TALLOC_CTX *mem_ctx,
166                                   const struct auth_context *auth_context,
167                                   const struct auth_usersupplied_info *user_info,
168                                   struct auth_serversupplied_info **pserver_info,
169                                   uint8_t *pauthoritative)
170 {
171         TALLOC_CTX *frame;
172         const char *auth_method_name = "";
173         /* if all the modules say 'not for me' this is reasonable */
174         NTSTATUS nt_status = NT_STATUS_NOT_IMPLEMENTED;
175         const char *unix_username;
176         auth_methods *auth_method;
177         struct auth_serversupplied_info *server_info = NULL;
178         struct dom_sid sid = {0};
179
180         if (user_info == NULL || auth_context == NULL || pserver_info == NULL) {
181                 return NT_STATUS_LOGON_FAILURE;
182         }
183
184         frame = talloc_stackframe();
185
186         *pauthoritative = 1;
187
188         DEBUG(3, ("check_ntlm_password:  Checking password for unmapped user [%s]\\[%s]@[%s] with the new password interface\n", 
189                   user_info->client.domain_name, user_info->client.account_name, user_info->workstation_name));
190
191         DEBUG(3, ("check_ntlm_password:  mapped user is: [%s]\\[%s]@[%s]\n", 
192                   user_info->mapped.domain_name, user_info->mapped.account_name, user_info->workstation_name));
193
194         if (auth_context->challenge.length != 8) {
195                 DEBUG(0, ("check_ntlm_password:  Invalid challenge stored for this auth context - cannot continue\n"));
196                 nt_status = NT_STATUS_LOGON_FAILURE;
197                 goto fail;
198         }
199
200         if (auth_context->challenge_set_by)
201                 DEBUG(10, ("check_ntlm_password: auth_context challenge created by %s\n",
202                                         auth_context->challenge_set_by));
203
204         DEBUG(10, ("challenge is: \n"));
205         dump_data(5, auth_context->challenge.data, auth_context->challenge.length);
206
207 #ifdef DEBUG_PASSWORD
208         DEBUG(100, ("user_info has passwords of length %d and %d\n", 
209                     (int)user_info->password.response.lanman.length, (int)user_info->password.response.nt.length));
210         DEBUG(100, ("lm:\n"));
211         dump_data(100, user_info->password.response.lanman.data, user_info->password.response.lanman.length);
212         DEBUG(100, ("nt:\n"));
213         dump_data(100, user_info->password.response.nt.data, user_info->password.response.nt.length);
214 #endif
215
216         /* This needs to be sorted:  If it doesn't match, what should we do? */
217         if (!check_domain_match(user_info->client.account_name,
218                                 user_info->mapped.domain_name)) {
219                 nt_status = NT_STATUS_LOGON_FAILURE;
220                 goto fail;
221         }
222
223         for (auth_method = auth_context->auth_method_list;auth_method; auth_method = auth_method->next) {
224
225                 auth_method_name = auth_method->name;
226
227                 nt_status = auth_method->auth(auth_context,
228                                               auth_method->private_data,
229                                               talloc_tos(),
230                                               user_info,
231                                               &server_info);
232
233                 if (!NT_STATUS_EQUAL(nt_status, NT_STATUS_NOT_IMPLEMENTED)) {
234                         break;
235                 }
236
237                 DBG_DEBUG("%s had nothing to say\n", auth_method->name);
238         }
239
240         if (NT_STATUS_EQUAL(nt_status, NT_STATUS_NOT_IMPLEMENTED)) {
241                 *pauthoritative = 0;
242                 nt_status = NT_STATUS_NO_SUCH_USER;
243         }
244
245         if (!NT_STATUS_IS_OK(nt_status)) {
246                 DBG_INFO("%s authentication for user [%s] FAILED with "
247                          "error %s, authoritative=%u\n",
248                          auth_method_name,
249                          user_info->client.account_name,
250                          nt_errstr(nt_status),
251                          *pauthoritative);
252                 goto fail;
253         }
254
255         DBG_NOTICE("%s authentication for user [%s] succeeded\n",
256                    auth_method_name, user_info->client.account_name);
257
258         unix_username = server_info->unix_name;
259
260         /* We skip doing this step if the caller asked us not to */
261         if (!(user_info->flags & USER_INFO_INFO3_AND_NO_AUTHZ)
262             && !(server_info->guest)) {
263                 const char *rhost;
264
265                 if (tsocket_address_is_inet(user_info->remote_host, "ip")) {
266                         rhost = tsocket_address_inet_addr_string(
267                                 user_info->remote_host, talloc_tos());
268                         if (rhost == NULL) {
269                                 nt_status = NT_STATUS_NO_MEMORY;
270                                 goto fail;
271                         }
272                 } else {
273                         rhost = "127.0.0.1";
274                 }
275
276                 /* We might not be root if we are an RPC call */
277                 become_root();
278                 nt_status = smb_pam_accountcheck(unix_username, rhost);
279                 unbecome_root();
280
281                 if (NT_STATUS_IS_OK(nt_status)) {
282                         DEBUG(5, ("check_ntlm_password:  PAM Account for user [%s] "
283                                   "succeeded\n", unix_username));
284                 } else {
285                         DEBUG(3, ("check_ntlm_password:  PAM Account for user [%s] "
286                                   "FAILED with error %s\n",
287                                   unix_username, nt_errstr(nt_status)));
288                 }
289         }
290
291         if (!NT_STATUS_IS_OK(nt_status)) {
292                 goto fail;
293         }
294
295         nt_status = get_user_sid_info3_and_extra(server_info->info3,
296                                                  &server_info->extra,
297                                                  &sid);
298         if (!NT_STATUS_IS_OK(nt_status)) {
299                 sid = (struct dom_sid) {0};
300         }
301
302         log_authentication_event(user_info, nt_status,
303                                  server_info->info3->base.logon_domain.string,
304                                  server_info->info3->base.account_name.string,
305                                  unix_username, &sid);
306
307         DEBUG(server_info->guest ? 5 : 2,
308               ("check_ntlm_password:  %sauthentication for user "
309                "[%s] -> [%s] -> [%s] succeeded\n",
310                server_info->guest ? "guest " : "",
311                user_info->client.account_name,
312                user_info->mapped.account_name,
313                unix_username));
314
315         *pserver_info = talloc_move(mem_ctx, &server_info);
316
317         TALLOC_FREE(frame);
318         return NT_STATUS_OK;
319
320 fail:
321
322         /* failed authentication; check for guest lapping */
323
324         /*
325          * Please try not to change this string, it is probably in use
326          * in audit logging tools
327          */
328         DEBUG(2, ("check_ntlm_password:  Authentication for user "
329                   "[%s] -> [%s] FAILED with error %s, authoritative=%u\n",
330                   user_info->client.account_name, user_info->mapped.account_name,
331                   nt_errstr(nt_status), *pauthoritative));
332
333         log_authentication_event(user_info, nt_status, NULL, NULL, NULL, NULL);
334
335         ZERO_STRUCTP(pserver_info);
336
337         TALLOC_FREE(frame);
338
339         return nt_status;
340 }
341
342 /***************************************************************************
343  Clear out a auth_context, and destroy the attached TALLOC_CTX
344 ***************************************************************************/
345
346 static int auth_context_destructor(void *ptr)
347 {
348         struct auth_context *ctx = talloc_get_type(ptr, struct auth_context);
349         struct auth_methods *am;
350
351
352         /* Free private data of context's authentication methods */
353         for (am = ctx->auth_method_list; am; am = am->next) {
354                 TALLOC_FREE(am->private_data);
355         }
356
357         return 0;
358 }
359
360 /***************************************************************************
361  Make a auth_info struct
362 ***************************************************************************/
363
364 static NTSTATUS make_auth_context(TALLOC_CTX *mem_ctx,
365                                   struct auth_context **auth_context)
366 {
367         struct auth_context *ctx;
368
369         ctx = talloc_zero(mem_ctx, struct auth_context);
370         if (!ctx) {
371                 DEBUG(0,("make_auth_context: talloc failed!\n"));
372                 return NT_STATUS_NO_MEMORY;
373         }
374
375         talloc_set_destructor((TALLOC_CTX *)ctx, auth_context_destructor);
376
377         *auth_context = ctx;
378         return NT_STATUS_OK;
379 }
380
381 bool load_auth_module(struct auth_context *auth_context, 
382                       const char *module, auth_methods **ret) 
383 {
384         static bool initialised_static_modules = False;
385
386         struct auth_init_function_entry *entry;
387         char *module_name = smb_xstrdup(module);
388         char *module_params = NULL;
389         char *p;
390         bool good = False;
391
392         /* Initialise static modules if not done so yet */
393         if(!initialised_static_modules) {
394                 static_init_auth;
395                 initialised_static_modules = True;
396         }
397
398         DEBUG(5,("load_auth_module: Attempting to find an auth method to match %s\n",
399                  module));
400
401         p = strchr(module_name, ':');
402         if (p) {
403                 *p = 0;
404                 module_params = p+1;
405                 trim_char(module_params, ' ', ' ');
406         }
407
408         trim_char(module_name, ' ', ' ');
409
410         entry = auth_find_backend_entry(module_name);
411
412         if (entry == NULL) {
413                 if (NT_STATUS_IS_OK(smb_probe_module("auth", module_name))) {
414                         entry = auth_find_backend_entry(module_name);
415                 }
416         }
417
418         if (entry != NULL) {
419                 if (!NT_STATUS_IS_OK(entry->init(auth_context, module_params, ret))) {
420                         DEBUG(0,("load_auth_module: auth method %s did not correctly init\n",
421                                  module_name));
422                 } else {
423                         DEBUG(5,("load_auth_module: auth method %s has a valid init\n",
424                                  module_name));
425                         good = True;
426                 }
427         } else {
428                 DEBUG(0,("load_auth_module: can't find auth method %s!\n", module_name));
429         }
430
431         SAFE_FREE(module_name);
432         return good;
433 }
434
435 /***************************************************************************
436  Make a auth_info struct for the auth subsystem
437 ***************************************************************************/
438
439 static NTSTATUS make_auth_context_text_list(TALLOC_CTX *mem_ctx,
440                                             struct auth_context **auth_context,
441                                             char **text_list)
442 {
443         auth_methods *list = NULL;
444         auth_methods *t, *method = NULL;
445         NTSTATUS nt_status;
446
447         if (!text_list) {
448                 DEBUG(2,("make_auth_context_text_list: No auth method list!?\n"));
449                 return NT_STATUS_UNSUCCESSFUL;
450         }
451
452         nt_status = make_auth_context(mem_ctx, auth_context);
453
454         if (!NT_STATUS_IS_OK(nt_status)) {
455                 return nt_status;
456         }
457
458         for (;*text_list; text_list++) { 
459                 if (load_auth_module(*auth_context, *text_list, &t)) {
460                     DLIST_ADD_END(list, t);
461                 }
462         }
463
464         (*auth_context)->auth_method_list = list;
465
466         /* Look for the first module to provide a prepare_gensec and
467          * make_auth4_context hook, and set that if provided */
468         for (method = (*auth_context)->auth_method_list; method; method = method->next) {
469                 if (method->prepare_gensec && method->make_auth4_context) {
470                         (*auth_context)->prepare_gensec = method->prepare_gensec;
471                         (*auth_context)->make_auth4_context = method->make_auth4_context;
472                         break;
473                 }
474         }
475         return NT_STATUS_OK;
476 }
477
478 static NTSTATUS make_auth_context_specific(TALLOC_CTX *mem_ctx,
479                                            struct auth_context **auth_context,
480                                            const char *methods)
481 {
482         char **method_list;
483         NTSTATUS status;
484
485         method_list = str_list_make_v3(talloc_tos(), methods, NULL);
486         if (method_list == NULL) {
487                 return NT_STATUS_NO_MEMORY;
488         }
489
490         status = make_auth_context_text_list(
491                 mem_ctx, auth_context, method_list);
492
493         TALLOC_FREE(method_list);
494
495         return status;
496 }
497
498 /***************************************************************************
499  Make a auth_context struct for the auth subsystem
500 ***************************************************************************/
501
502 static NTSTATUS make_auth_context_subsystem(TALLOC_CTX *mem_ctx,
503                                             struct auth_context **auth_context)
504 {
505         const char *methods = NULL;
506         NTSTATUS nt_status;
507
508         switch (lp_server_role()) {
509         case ROLE_ACTIVE_DIRECTORY_DC:
510                 DEBUG(5,("Making default auth method list for server role = "
511                          "'active directory domain controller'\n"));
512                 return make_auth_context_specific(mem_ctx, auth_context, "samba4");
513         default:
514                 break;
515         }
516
517         if (lp_auth_methods()) {
518                 DEBUG(5,("Using specified auth order\n"));
519                 nt_status = make_auth_context_text_list(
520                         mem_ctx, auth_context,
521                         discard_const_p(char *, lp_auth_methods()));
522                 return nt_status;
523         }
524
525         switch (lp_server_role()) {
526         case ROLE_DOMAIN_MEMBER:
527                 DEBUG(5,("Making default auth method list for server role = 'domain member'\n"));
528                 methods = "guest sam winbind:ntdomain";
529                 break;
530         case ROLE_DOMAIN_BDC:
531         case ROLE_DOMAIN_PDC:
532                 DEBUG(5,("Making default auth method list for DC\n"));
533                 methods = "guest sam winbind:trustdomain";
534                 break;
535         case ROLE_STANDALONE:
536                 DEBUG(5,("Making default auth method list for server role = 'standalone server', encrypt passwords = yes\n"));
537                 if (lp_encrypt_passwords()) {
538                         methods = "guest sam";
539                 } else {
540                         DEBUG(5,("Making default auth method list for server role = 'standalone server', encrypt passwords = no\n"));
541                         methods = "guest unix";
542                 }
543                 break;
544         default:
545                 DEBUG(5,("Unknown auth method!\n"));
546                 return NT_STATUS_UNSUCCESSFUL;
547         }
548
549         return make_auth_context_specific(mem_ctx, auth_context, methods);
550 }
551
552 NTSTATUS make_auth3_context_for_ntlm(TALLOC_CTX *mem_ctx,
553                                      struct auth_context **auth_context)
554 {
555         return make_auth_context_subsystem(mem_ctx, auth_context);
556 }
557
558 NTSTATUS make_auth3_context_for_netlogon(TALLOC_CTX *mem_ctx,
559                                          struct auth_context **auth_context)
560 {
561         return make_auth_context_subsystem(mem_ctx, auth_context);
562 }
563
564 NTSTATUS make_auth3_context_for_winbind(TALLOC_CTX *mem_ctx,
565                                         struct auth_context **auth_context)
566 {
567         const char *methods = NULL;
568
569         switch (lp_server_role()) {
570         case ROLE_STANDALONE:
571         case ROLE_DOMAIN_MEMBER:
572         case ROLE_DOMAIN_BDC:
573         case ROLE_DOMAIN_PDC:
574                 methods = "sam";
575                 break;
576         case ROLE_ACTIVE_DIRECTORY_DC:
577                 methods = "samba4:sam";
578                 break;
579         default:
580                 DEBUG(5,("Unknown auth method!\n"));
581                 return NT_STATUS_UNSUCCESSFUL;
582         }
583
584         return make_auth_context_specific(mem_ctx, auth_context, methods);
585 }
586
587 bool auth3_context_set_challenge(struct auth_context *ctx, uint8_t chal[8],
588                                  const char *challenge_set_by)
589 {
590         ctx->challenge = data_blob_talloc(ctx, chal, 8);
591         if (ctx->challenge.data == NULL) {
592                 return false;
593         }
594         ctx->challenge_set_by = talloc_strdup(ctx, challenge_set_by);
595         if (ctx->challenge_set_by == NULL) {
596                 return false;
597         }
598         return true;
599 }