s3:pam_smbpass: don't call openlog() or closelog() from pam_smbpass
[ira/wip.git] / source3 / pam_smbpass / support.c
1 /* Unix NT password database implementation, version 0.6.
2  *
3  * This program is free software; you can redistribute it and/or modify it under
4  * the terms of the GNU General Public License as published by the Free
5  * Software Foundation; either version 3 of the License, or (at your option)
6  * any later version.
7  *
8  * This program is distributed in the hope that it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  *
13  * You should have received a copy of the GNU General Public License along with
14  * this program; if not, see <http://www.gnu.org/licenses/>.
15  */
16
17 #include "config.h"
18 #include "includes.h"
19 #include "general.h"
20
21 #include "support.h"
22
23 #include "../libcli/auth/libcli_auth.h"
24
25
26 #define _pam_overwrite(x)        \
27 do {                             \
28      register char *__xx__;      \
29      if ((__xx__=(x)))           \
30           while (*__xx__)        \
31                *__xx__++ = '\0'; \
32 } while (0)
33
34 /*
35  * Don't just free it, forget it too.
36  */
37
38 #define _pam_drop(X) \
39 do {                 \
40     if (X) {         \
41         free(X);     \
42         X=NULL;      \
43     }                \
44 } while (0)
45
46 #define _pam_drop_reply(/* struct pam_response * */ reply, /* int */ replies) \
47 do {                                              \
48     int reply_i;                                  \
49                                                   \
50     for (reply_i=0; reply_i<replies; ++reply_i) { \
51         if (reply[reply_i].resp) {                \
52             _pam_overwrite(reply[reply_i].resp);  \
53             free(reply[reply_i].resp);            \
54         }                                         \
55     }                                             \
56     if (reply)                                    \
57         free(reply);                              \
58 } while (0)
59
60
61 int converse(pam_handle_t *, int, int, struct pam_message **,
62                          struct pam_response **);
63 int make_remark(pam_handle_t *, unsigned int, int, const char *);
64 void _cleanup(pam_handle_t *, void *, int);
65 char *_pam_delete(register char *);
66
67 /* syslogging function for errors and other information */
68 #ifdef HAVE_PAM_VSYSLOG
69 void _log_err( pam_handle_t *pamh, int err, const char *format, ... )
70 {
71         va_list args;
72
73         va_start(args, format);
74         pam_vsyslog(pamh, err, format, args);
75         va_end(args);
76 }
77 #else
78 void _log_err( pam_handle_t *pamh, int err, const char *format, ... )
79 {
80         va_list args;
81         const char tag[] = "(pam_smbpass) ";
82         char *mod_format;
83
84         mod_format = SMB_MALLOC_ARRAY(char, sizeof(tag) + strlen(format));
85         /* try really, really hard to log something, since this may have
86            been a message about a malloc() failure... */
87         if (mod_format == NULL) {
88                 va_start(args, format);
89                 vsyslog(err | LOG_AUTH, format, args);
90                 va_end(args);
91                 return;
92         }
93
94         strncpy(mod_format, tag, strlen(tag)+1);
95         strncat(mod_format, format, strlen(format));
96
97         va_start(args, format);
98         vsyslog(err | LOG_AUTH, mod_format, args);
99         va_end(args);
100
101         free(mod_format);
102 }
103 #endif
104
105 /* this is a front-end for module-application conversations */
106
107 int converse( pam_handle_t * pamh, int ctrl, int nargs
108               , struct pam_message **message
109               , struct pam_response **response )
110 {
111         int retval;
112         struct pam_conv *conv;
113
114         retval = _pam_get_item(pamh, PAM_CONV, &conv);
115         if (retval == PAM_SUCCESS) {
116
117                 retval = conv->conv(nargs, (const struct pam_message **) message
118                                                         ,response, conv->appdata_ptr);
119
120                 if (retval != PAM_SUCCESS && on(SMB_DEBUG, ctrl)) {
121                         _log_err(pamh, LOG_DEBUG, "conversation failure [%s]"
122                                          ,pam_strerror(pamh, retval));
123                 }
124         } else {
125                 _log_err(pamh, LOG_ERR, "couldn't obtain coversation function [%s]"
126                                  ,pam_strerror(pamh, retval));
127         }
128
129         return retval;                          /* propagate error status */
130 }
131
132 int make_remark( pam_handle_t * pamh, unsigned int ctrl
133                  , int type, const char *text )
134 {
135         if (off(SMB__QUIET, ctrl)) {
136                 struct pam_message *pmsg[1], msg[1];
137                 struct pam_response *resp;
138
139                 pmsg[0] = &msg[0];
140                 msg[0].msg = CONST_DISCARD(char *, text);
141                 msg[0].msg_style = type;
142                 resp = NULL;
143
144                 return converse(pamh, ctrl, 1, pmsg, &resp);
145         }
146         return PAM_SUCCESS;
147 }
148
149
150 /* set the control flags for the SMB module. */
151
152 int set_ctrl( pam_handle_t *pamh, int flags, int argc, const char **argv )
153 {
154     int i = 0;
155     const char *service_file = NULL;
156     unsigned int ctrl;
157
158     ctrl = SMB_DEFAULTS;        /* the default selection of options */
159
160     /* set some flags manually */
161
162     /* A good, sane default (matches Samba's behavior). */
163     set( SMB__NONULL, ctrl );
164
165     /* initialize service file location */
166     service_file=get_dyn_CONFIGFILE();
167
168     if (flags & PAM_SILENT) {
169         set( SMB__QUIET, ctrl );
170     }
171
172     /* Run through the arguments once, looking for an alternate smb config
173        file location */
174     while (i < argc) {
175         int j;
176
177         for (j = 0; j < SMB_CTRLS_; ++j) {
178             if (smb_args[j].token
179                 && !strncmp(argv[i], smb_args[j].token, strlen(smb_args[j].token)))
180             {
181                 break;
182             }
183         }
184
185         if (j == SMB_CONF_FILE) {
186             service_file = argv[i] + 8;
187         }
188         i++;
189     }
190
191     /* Read some options from the Samba config. Can be overridden by
192        the PAM config. */
193     if(lp_load(service_file,True,False,False,True) == False) {
194         _log_err(pamh, LOG_ERR, "Error loading service file %s", service_file);
195     }
196
197     secrets_init();
198
199     if (lp_null_passwords()) {
200         set( SMB__NULLOK, ctrl );
201     }
202
203     /* now parse the rest of the arguments to this module */
204
205     while (argc-- > 0) {
206         int j;
207
208         for (j = 0; j < SMB_CTRLS_; ++j) {
209             if (smb_args[j].token
210                 && !strncmp(*argv, smb_args[j].token, strlen(smb_args[j].token)))
211             {
212                 break;
213             }
214         }
215
216         if (j >= SMB_CTRLS_) {
217             _log_err(pamh, LOG_ERR, "unrecognized option [%s]", *argv);
218         } else {
219             ctrl &= smb_args[j].mask;   /* for turning things off */
220             ctrl |= smb_args[j].flag;   /* for turning things on  */
221         }
222
223         ++argv;                         /* step to next argument */
224     }
225
226     /* auditing is a more sensitive version of debug */
227
228     if (on( SMB_AUDIT, ctrl )) {
229         set( SMB_DEBUG, ctrl );
230     }
231     /* return the set of flags */
232
233     return ctrl;
234 }
235
236 /* use this to free strings. ESPECIALLY password strings */
237
238 char * _pam_delete( register char *xx )
239 {
240     _pam_overwrite( xx );
241     _pam_drop( xx );
242     return NULL;
243 }
244
245 void _cleanup( pam_handle_t * pamh, void *x, int error_status )
246 {
247     x = _pam_delete( (char *) x );
248 }
249
250 /* JHT
251  *
252  * Safe duplication of character strings. "Paranoid"; don't leave
253  * evidence of old token around for later stack analysis.
254  *
255  */
256 char * smbpXstrDup( pam_handle_t *pamh, const char *x )
257 {
258     register char *newstr = NULL;
259
260     if (x != NULL) {
261         register int i;
262
263         for (i = 0; x[i]; ++i); /* length of string */
264         if ((newstr = SMB_MALLOC_ARRAY(char, ++i)) == NULL) {
265             i = 0;
266             _log_err(pamh, LOG_CRIT, "out of memory in smbpXstrDup");
267         } else {
268             while (i-- > 0) {
269                 newstr[i] = x[i];
270             }
271         }
272         x = NULL;
273     }
274     return newstr;                      /* return the duplicate or NULL on error */
275 }
276
277 /* ************************************************************** *
278  * Useful non-trivial functions                                   *
279  * ************************************************************** */
280
281 void _cleanup_failures( pam_handle_t * pamh, void *fl, int err )
282 {
283     int quiet;
284     const char *service = NULL;
285     struct _pam_failed_auth *failure;
286
287 #ifdef PAM_DATA_SILENT
288     quiet = err & PAM_DATA_SILENT;      /* should we log something? */
289 #else
290     quiet = 0;
291 #endif
292 #ifdef PAM_DATA_REPLACE
293     err &= PAM_DATA_REPLACE;    /* are we just replacing data? */
294 #endif
295     failure = (struct _pam_failed_auth *) fl;
296
297     if (failure != NULL) {
298
299 #ifdef PAM_DATA_SILENT
300         if (!quiet && !err) {   /* under advisement from Sun,may go away */
301 #else
302         if (!quiet) {   /* under advisement from Sun,may go away */
303 #endif
304
305             /* log the number of authentication failures */
306             if (failure->count != 0) {
307                 _pam_get_item( pamh, PAM_SERVICE, &service );
308                 _log_err(pamh, LOG_NOTICE
309                           , "%d authentication %s "
310                             "from %s for service %s as %s(%d)"
311                           , failure->count
312                           , failure->count == 1 ? "failure" : "failures"
313                           , failure->agent
314                           , service == NULL ? "**unknown**" : service 
315                           , failure->user, failure->id );
316                 if (failure->count > SMB_MAX_RETRIES) {
317                     _log_err(pamh, LOG_ALERT
318                               , "service(%s) ignoring max retries; %d > %d"
319                               , service == NULL ? "**unknown**" : service
320                               , failure->count
321                               , SMB_MAX_RETRIES );
322                 }
323             }
324         }
325         _pam_delete( failure->agent );  /* tidy up */
326         _pam_delete( failure->user );   /* tidy up */
327         SAFE_FREE( failure );
328     }
329 }
330
331 int _smb_verify_password( pam_handle_t * pamh, struct samu *sampass,
332                           const char *p, unsigned int ctrl )
333 {
334     uchar lm_pw[16];
335     uchar nt_pw[16];
336     int retval = PAM_AUTH_ERR;
337     char *data_name;
338     const char *name;
339
340     if (!sampass)
341         return PAM_ABORT;
342
343     name = pdb_get_username(sampass);
344
345 #ifdef HAVE_PAM_FAIL_DELAY
346     if (off( SMB_NODELAY, ctrl )) {
347         (void) pam_fail_delay( pamh, 1000000 ); /* 1 sec delay for on failure */
348     }
349 #endif
350
351     if (!pdb_get_nt_passwd(sampass))
352     {
353         _log_err(pamh, LOG_DEBUG, "user %s has null SMB password", name);
354
355         if (off( SMB__NONULL, ctrl )
356             && (pdb_get_acct_ctrl(sampass) & ACB_PWNOTREQ))
357         { /* this means we've succeeded */
358             return PAM_SUCCESS;
359         } else {
360             const char *service;
361
362             _pam_get_item( pamh, PAM_SERVICE, &service );
363             _log_err(pamh, LOG_NOTICE, "failed auth request by %s for service %s as %s",
364                       uidtoname(getuid()), service ? service : "**unknown**", name);
365             return PAM_AUTH_ERR;
366         }
367     }
368
369     data_name = SMB_MALLOC_ARRAY(char, sizeof(FAIL_PREFIX) + strlen( name ));
370     if (data_name == NULL) {
371         _log_err(pamh, LOG_CRIT, "no memory for data-name" );
372         return PAM_AUTH_ERR;
373     }
374     strncpy( data_name, FAIL_PREFIX, sizeof(FAIL_PREFIX) );
375     strncpy( data_name + sizeof(FAIL_PREFIX) - 1, name, strlen( name ) + 1 );
376
377     /*
378      * The password we were given wasn't an encrypted password, or it
379      * didn't match the one we have.  We encrypt the password now and try
380      * again.
381      */
382
383     nt_lm_owf_gen(p, nt_pw, lm_pw);
384
385     /* the moment of truth -- do we agree with the password? */
386
387     if (!memcmp( nt_pw, pdb_get_nt_passwd(sampass), 16 )) {
388
389         retval = PAM_SUCCESS;
390         if (data_name) {                /* reset failures */
391             pam_set_data(pamh, data_name, NULL, _cleanup_failures);
392         }
393     } else {
394
395         const char *service;
396
397         _pam_get_item( pamh, PAM_SERVICE, &service );
398
399         if (data_name != NULL) {
400             struct _pam_failed_auth *newauth = NULL;
401             const struct _pam_failed_auth *old = NULL;
402
403             /* get a failure recorder */
404
405             newauth = SMB_MALLOC_P( struct _pam_failed_auth );
406
407             if (newauth != NULL) {
408
409                 /* any previous failures for this user ? */
410                 _pam_get_data(pamh, data_name, &old);
411
412                 if (old != NULL) {
413                     newauth->count = old->count + 1;
414                     if (newauth->count >= SMB_MAX_RETRIES) {
415                         retval = PAM_MAXTRIES;
416                     }
417                 } else {
418                     _log_err(pamh, LOG_NOTICE,
419                       "failed auth request by %s for service %s as %s",
420                       uidtoname(getuid()),
421                       service ? service : "**unknown**", name);
422                     newauth->count = 1;
423                 }
424                 if (!sid_to_uid(pdb_get_user_sid(sampass), &(newauth->id))) {
425                     _log_err(pamh, LOG_NOTICE,
426                       "failed auth request by %s for service %s as %s",
427                       uidtoname(getuid()),
428                       service ? service : "**unknown**", name);
429                 }               
430                 newauth->user = smbpXstrDup( pamh, name );
431                 newauth->agent = smbpXstrDup( pamh, uidtoname( getuid() ) );
432                 pam_set_data( pamh, data_name, newauth, _cleanup_failures );
433
434             } else {
435                 _log_err(pamh, LOG_CRIT, "no memory for failure recorder" );
436                 _log_err(pamh, LOG_NOTICE,
437                       "failed auth request by %s for service %s as %s(%d)",
438                       uidtoname(getuid()),
439                       service ? service : "**unknown**", name);
440             }
441         }
442         _log_err(pamh, LOG_NOTICE,
443                   "failed auth request by %s for service %s as %s(%d)",
444                   uidtoname(getuid()),
445                   service ? service : "**unknown**", name);
446         retval = PAM_AUTH_ERR;
447     }
448
449     _pam_delete( data_name );
450
451     return retval;
452 }
453
454
455 /*
456  * _smb_blankpasswd() is a quick check for a blank password
457  *
458  * returns TRUE if user does not have a password
459  * - to avoid prompting for one in such cases (CG)
460  */
461
462 int _smb_blankpasswd( unsigned int ctrl, struct samu *sampass )
463 {
464         int retval;
465
466         /*
467          * This function does not have to be too smart if something goes
468          * wrong, return FALSE and let this case to be treated somewhere
469          * else (CG)
470          */
471
472         if (on( SMB__NONULL, ctrl ))
473                 return 0;               /* will fail but don't let on yet */
474
475         if (!(pdb_get_acct_ctrl(sampass) & ACB_PWNOTREQ))
476                 return 0;
477
478         if (pdb_get_nt_passwd(sampass) == NULL)
479                 retval = 1;
480         else
481                 retval = 0;
482
483         return retval;
484 }
485
486 /*
487  * obtain a password from the user
488  */
489
490 int _smb_read_password( pam_handle_t * pamh, unsigned int ctrl,
491                         const char *comment, const char *prompt1,
492                         const char *prompt2, const char *data_name, char **pass )
493 {
494     int authtok_flag;
495     int retval;
496     char *item = NULL;
497     char *token;
498
499     struct pam_message msg[3], *pmsg[3];
500     struct pam_response *resp;
501     int i, expect;
502
503
504     /* make sure nothing inappropriate gets returned */
505
506     *pass = token = NULL;
507
508     /* which authentication token are we getting? */
509
510     authtok_flag = on(SMB__OLD_PASSWD, ctrl) ? PAM_OLDAUTHTOK : PAM_AUTHTOK;
511
512     /* should we obtain the password from a PAM item ? */
513
514     if (on(SMB_TRY_FIRST_PASS, ctrl) || on(SMB_USE_FIRST_PASS, ctrl)) {
515         retval = _pam_get_item( pamh, authtok_flag, &item );
516         if (retval != PAM_SUCCESS) {
517             /* very strange. */
518             _log_err(pamh, LOG_ALERT,
519                      "pam_get_item returned error to smb_read_password");
520             return retval;
521         } else if (item != NULL) {      /* we have a password! */
522             *pass = item;
523             item = NULL;
524             return PAM_SUCCESS;
525         } else if (on( SMB_USE_FIRST_PASS, ctrl )) {
526             return PAM_AUTHTOK_RECOVER_ERR;             /* didn't work */
527         } else if (on( SMB_USE_AUTHTOK, ctrl )
528                    && off( SMB__OLD_PASSWD, ctrl ))
529         {
530             return PAM_AUTHTOK_RECOVER_ERR;
531         }
532     }
533
534     /*
535      * getting here implies we will have to get the password from the
536      * user directly.
537      */
538
539     /* prepare to converse */
540     if (comment != NULL && off(SMB__QUIET, ctrl)) {
541         pmsg[0] = &msg[0];
542         msg[0].msg_style = PAM_TEXT_INFO;
543         msg[0].msg = CONST_DISCARD(char *, comment);
544         i = 1;
545     } else {
546         i = 0;
547     }
548
549     pmsg[i] = &msg[i];
550     msg[i].msg_style = PAM_PROMPT_ECHO_OFF;
551     msg[i++].msg = CONST_DISCARD(char *, prompt1);
552
553     if (prompt2 != NULL) {
554         pmsg[i] = &msg[i];
555         msg[i].msg_style = PAM_PROMPT_ECHO_OFF;
556         msg[i++].msg = CONST_DISCARD(char *, prompt2);
557         expect = 2;
558     } else
559         expect = 1;
560
561     resp = NULL;
562
563     retval = converse( pamh, ctrl, i, pmsg, &resp );
564
565     if (resp != NULL) {
566         int j = comment ? 1 : 0;
567         /* interpret the response */
568
569         if (retval == PAM_SUCCESS) {    /* a good conversation */
570
571             token = smbpXstrDup(pamh, resp[j++].resp);
572             if (token != NULL) {
573                 if (expect == 2) {
574                     /* verify that password entered correctly */
575                     if (!resp[j].resp || strcmp( token, resp[j].resp )) {
576                         _pam_delete( token );
577                         retval = PAM_AUTHTOK_RECOVER_ERR;
578                         make_remark( pamh, ctrl, PAM_ERROR_MSG
579                                      , MISTYPED_PASS );
580                     }
581                 }
582             } else {
583                 _log_err(pamh, LOG_NOTICE,
584                          "could not recover authentication token");
585             }
586         }
587
588         /* tidy up */
589         _pam_drop_reply( resp, expect );
590
591     } else {
592         retval = (retval == PAM_SUCCESS) ? PAM_AUTHTOK_RECOVER_ERR : retval;
593     }
594
595     if (retval != PAM_SUCCESS) {
596         if (on( SMB_DEBUG, ctrl ))
597             _log_err(pamh, LOG_DEBUG, "unable to obtain a password");
598         return retval;
599     }
600     /* 'token' is the entered password */
601
602     if (off( SMB_NOT_SET_PASS, ctrl )) {
603
604         /* we store this password as an item */
605
606         retval = pam_set_item( pamh, authtok_flag, (const void *)token );
607         _pam_delete( token );           /* clean it up */
608         if (retval != PAM_SUCCESS
609             || (retval = _pam_get_item( pamh, authtok_flag
610                             ,&item )) != PAM_SUCCESS)
611         {
612             _log_err(pamh, LOG_CRIT, "error manipulating password");
613             return retval;
614         }
615     } else {
616         /*
617          * then store it as data specific to this module. pam_end()
618          * will arrange to clean it up.
619          */
620
621         retval = pam_set_data( pamh, data_name, (void *) token, _cleanup );
622         if (retval != PAM_SUCCESS
623             || (retval = _pam_get_data( pamh, data_name, &item ))
624                              != PAM_SUCCESS)
625         {
626             _log_err(pamh, LOG_CRIT, "error manipulating password data [%s]",
627                      pam_strerror( pamh, retval ));
628             _pam_delete( token );
629             item = NULL;
630             return retval;
631         }
632         token = NULL;                   /* break link to password */
633     }
634
635     *pass = item;
636     item = NULL;                        /* break link to password */
637
638     return PAM_SUCCESS;
639 }
640
641 int _pam_smb_approve_pass(pam_handle_t * pamh,
642                 unsigned int ctrl,
643                 const char *pass_old,
644                 const char *pass_new )
645 {
646
647     /* Further checks should be handled through module stacking. -SRL */
648     if (pass_new == NULL || (pass_old && !strcmp( pass_old, pass_new )))
649     {
650         if (on(SMB_DEBUG, ctrl)) {
651             _log_err(pamh, LOG_DEBUG,
652                      "passwd: bad authentication token (null or unchanged)");
653         }
654         make_remark( pamh, ctrl, PAM_ERROR_MSG, pass_new == NULL ?
655                                 "No password supplied" : "Password unchanged" );
656         return PAM_AUTHTOK_ERR;
657     }
658
659     return PAM_SUCCESS;
660 }
661
662 /*
663  * Work around the pam API that has functions with void ** as parameters
664  * These lead to strict aliasing warnings with gcc.
665  */
666 int _pam_get_item(const pam_handle_t *pamh,
667                   int item_type,
668                   const void *_item)
669 {
670         const void **item = (const void **)_item;
671         return pam_get_item(pamh, item_type, item);
672 }
673
674 int _pam_get_data(const pam_handle_t *pamh,
675                   const char *module_data_name,
676                   const void *_data)
677 {
678         const void **data = (const void **)_data;
679         return pam_get_data(pamh, module_data_name, data);
680 }