extend syntax for allowable hosts in secrets files;
[ppp.git] / pppd / auth.c
1 /*
2  * auth.c - PPP authentication and phase control.
3  *
4  * Copyright (c) 1993 The Australian National University.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms are permitted
8  * provided that the above copyright notice and this paragraph are
9  * duplicated in all such forms and that any documentation,
10  * advertising materials, and other materials related to such
11  * distribution and use acknowledge that the software was developed
12  * by the Australian National University.  The name of the University
13  * may not be used to endorse or promote products derived from this
14  * software without specific prior written permission.
15  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18  *
19  * Copyright (c) 1989 Carnegie Mellon University.
20  * All rights reserved.
21  *
22  * Redistribution and use in source and binary forms are permitted
23  * provided that the above copyright notice and this paragraph are
24  * duplicated in all such forms and that any documentation,
25  * advertising materials, and other materials related to such
26  * distribution and use acknowledge that the software was developed
27  * by Carnegie Mellon University.  The name of the
28  * University may not be used to endorse or promote products derived
29  * from this software without specific prior written permission.
30  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
31  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
32  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
33  */
34
35 #ifndef lint
36 static char rcsid[] = "$Id: auth.c,v 1.20 1995/12/18 03:43:04 paulus Exp $";
37 #endif
38
39 #include <stdio.h>
40 #include <stddef.h>
41 #include <stdlib.h>
42 #include <syslog.h>
43 #include <pwd.h>
44 #include <string.h>
45 #include <sys/types.h>
46 #include <sys/stat.h>
47 #include <sys/socket.h>
48
49 #include <netdb.h>
50 #include <netinet/in.h>
51 #include <arpa/inet.h>
52
53 #ifdef HAS_SHADOW
54 #include <shadow.h>
55 #include <shadow/pwauth.h>
56 #ifndef PW_PPP
57 #define PW_PPP PW_LOGIN
58 #endif
59 #endif
60
61 #include "pppd.h"
62 #include "fsm.h"
63 #include "lcp.h"
64 #include "upap.h"
65 #include "pathnames.h"
66
67 #if defined(sun) && defined(sparc)
68 #include <alloca.h>
69 #endif /*sparc*/
70
71 /* Used for storing a sequence of words.  Usually malloced. */
72 struct wordlist {
73     struct wordlist     *next;
74     char                word[1];
75 };
76
77 /* Bits in scan_authfile return value */
78 #define NONWILD_SERVER  1
79 #define NONWILD_CLIENT  2
80
81 #define ISWILD(word)    (word[0] == '*' && word[1] == 0)
82
83 #define FALSE   0
84 #define TRUE    1
85
86 /* Records which authentication operations haven't completed yet. */
87 static int auth_pending[NUM_PPP];
88 static int logged_in;
89 static struct wordlist *addresses[NUM_PPP];
90
91 /* Bits in auth_pending[] */
92 #define UPAP_WITHPEER   1
93 #define UPAP_PEER       2
94 #define CHAP_WITHPEER   4
95 #define CHAP_PEER       8
96
97 /* Prototypes for procedures local to this file. */
98
99 static void network_phase __P((int));
100 static int  login __P((char *, char *, char **, int *));
101 static void logout __P((void));
102 static int  null_login __P((int));
103 static int  get_upap_passwd __P((void));
104 static int  have_upap_secret __P((void));
105 static int  have_chap_secret __P((char *, char *));
106 static int  scan_authfile __P((FILE *, char *, char *, char *,
107                                   struct wordlist **, char *));
108 static void free_wordlist __P((struct wordlist *));
109
110 extern char *crypt __P((char *, char *));
111
112 /*
113  * An Open on LCP has requested a change from Dead to Establish phase.
114  * Do what's necessary to bring the physical layer up.
115  */
116 void
117 link_required(unit)
118     int unit;
119 {
120 }
121
122 /*
123  * LCP has terminated the link; go to the Dead phase and take the
124  * physical layer down.
125  */
126 void
127 link_terminated(unit)
128     int unit;
129 {
130     if (phase == PHASE_DEAD)
131         return;
132     if (logged_in)
133         logout();
134     phase = PHASE_DEAD;
135     syslog(LOG_NOTICE, "Connection terminated.");
136 }
137
138 /*
139  * LCP has gone down; it will either die or try to re-establish.
140  */
141 void
142 link_down(unit)
143     int unit;
144 {
145     int i;
146     struct protent *protp;
147
148     for (i = 0; (protp = protocols[i]) != NULL; ++i) {
149         if (protp->protocol != PPP_LCP && protp->lowerdown != NULL)
150             (*protp->lowerdown)(unit);
151         if (protp->protocol < 0xC000 && protp->close != NULL)
152             (*protp->close)(unit);
153     }
154     phase = PHASE_TERMINATE;
155 }
156
157 /*
158  * The link is established.
159  * Proceed to the Dead, Authenticate or Network phase as appropriate.
160  */
161 void
162 link_established(unit)
163     int unit;
164 {
165     int auth;
166     lcp_options *wo = &lcp_wantoptions[unit];
167     lcp_options *go = &lcp_gotoptions[unit];
168     lcp_options *ho = &lcp_hisoptions[unit];
169     int i;
170     struct protent *protp;
171
172     /*
173      * Tell higher-level protocols that LCP is up.
174      */
175     for (i = 0; (protp = protocols[i]) != NULL; ++i)
176         if (protp->protocol != PPP_LCP && protp->lowerup != NULL)
177             (*protp->lowerup)(unit);
178
179     if (auth_required && !(go->neg_chap || go->neg_upap)) {
180         /*
181          * We wanted the peer to authenticate itself, and it refused:
182          * treat it as though it authenticated with PAP using a username
183          * of "" and a password of "".  If that's not OK, boot it out.
184          */
185         if (!wo->neg_upap || !null_login(unit)) {
186             syslog(LOG_WARNING, "peer refused to authenticate");
187             lcp_close(unit, "peer refused to authenticate");
188             phase = PHASE_TERMINATE;
189             return;
190         }
191     }
192
193     phase = PHASE_AUTHENTICATE;
194     auth = 0;
195     if (go->neg_chap) {
196         ChapAuthPeer(unit, our_name, go->chap_mdtype);
197         auth |= CHAP_PEER;
198     } else if (go->neg_upap) {
199         upap_authpeer(unit);
200         auth |= UPAP_PEER;
201     }
202     if (ho->neg_chap) {
203         ChapAuthWithPeer(unit, our_name, ho->chap_mdtype);
204         auth |= CHAP_WITHPEER;
205     } else if (ho->neg_upap) {
206         upap_authwithpeer(unit, user, passwd);
207         auth |= UPAP_WITHPEER;
208     }
209     auth_pending[unit] = auth;
210
211     if (!auth)
212         network_phase(unit);
213 }
214
215 /*
216  * Proceed to the network phase.
217  */
218 static void
219 network_phase(unit)
220     int unit;
221 {
222     int i;
223     struct protent *protp;
224
225     phase = PHASE_NETWORK;
226     for (i = 0; (protp = protocols[i]) != NULL; ++i)
227         if (protp->protocol < 0xC000 && protp->open != NULL)
228             (*protp->open)(unit);
229 }
230
231 /*
232  * The peer has failed to authenticate himself using `protocol'.
233  */
234 void
235 auth_peer_fail(unit, protocol)
236     int unit, protocol;
237 {
238     /*
239      * Authentication failure: take the link down
240      */
241     lcp_close(unit, "Authentication failed");
242     phase = PHASE_TERMINATE;
243 }
244
245 /*
246  * The peer has been successfully authenticated using `protocol'.
247  */
248 void
249 auth_peer_success(unit, protocol)
250     int unit, protocol;
251 {
252     int bit;
253
254     switch (protocol) {
255     case PPP_CHAP:
256         bit = CHAP_PEER;
257         break;
258     case PPP_PAP:
259         bit = UPAP_PEER;
260         break;
261     default:
262         syslog(LOG_WARNING, "auth_peer_success: unknown protocol %x",
263                protocol);
264         return;
265     }
266
267     /*
268      * If there is no more authentication still to be done,
269      * proceed to the network phase.
270      */
271     if ((auth_pending[unit] &= ~bit) == 0)
272         network_phase(unit);
273 }
274
275 /*
276  * We have failed to authenticate ourselves to the peer using `protocol'.
277  */
278 void
279 auth_withpeer_fail(unit, protocol)
280     int unit, protocol;
281 {
282     /*
283      * We've failed to authenticate ourselves to our peer.
284      * He'll probably take the link down, and there's not much
285      * we can do except wait for that.
286      */
287 }
288
289 /*
290  * We have successfully authenticated ourselves with the peer using `protocol'.
291  */
292 void
293 auth_withpeer_success(unit, protocol)
294     int unit, protocol;
295 {
296     int bit;
297
298     switch (protocol) {
299     case PPP_CHAP:
300         bit = CHAP_WITHPEER;
301         break;
302     case PPP_PAP:
303         bit = UPAP_WITHPEER;
304         break;
305     default:
306         syslog(LOG_WARNING, "auth_peer_success: unknown protocol %x",
307                protocol);
308         bit = 0;
309     }
310
311     /*
312      * If there is no more authentication still being done,
313      * proceed to the network phase.
314      */
315     if ((auth_pending[unit] &= ~bit) == 0)
316         network_phase(unit);
317 }
318
319
320 /*
321  * check_auth_options - called to check authentication options.
322  */
323 void
324 check_auth_options()
325 {
326     lcp_options *wo = &lcp_wantoptions[0];
327     lcp_options *ao = &lcp_allowoptions[0];
328
329     /* Default our_name to hostname, and user to our_name */
330     if (our_name[0] == 0 || usehostname)
331         strcpy(our_name, hostname);
332     if (user[0] == 0)
333         strcpy(user, our_name);
334
335     /* If authentication is required, ask peer for CHAP or PAP. */
336     if (auth_required && !wo->neg_chap && !wo->neg_upap) {
337         wo->neg_chap = 1;
338         wo->neg_upap = 1;
339     }
340
341     /*
342      * Check whether we have appropriate secrets to use
343      * to authenticate ourselves and/or the peer.
344      */
345     if (ao->neg_upap && passwd[0] == 0 && !get_upap_passwd())
346         ao->neg_upap = 0;
347     if (wo->neg_upap && !uselogin && !have_upap_secret())
348         wo->neg_upap = 0;
349     if (ao->neg_chap && !have_chap_secret(our_name, remote_name))
350         ao->neg_chap = 0;
351     if (wo->neg_chap && !have_chap_secret(remote_name, our_name))
352         wo->neg_chap = 0;
353
354     if (auth_required && !wo->neg_chap && !wo->neg_upap) {
355         fprintf(stderr, "\
356 pppd: peer authentication required but no authentication files accessible\n");
357         exit(1);
358     }
359
360 }
361
362
363 /*
364  * check_passwd - Check the user name and passwd against the PAP secrets
365  * file.  If requested, also check against the system password database,
366  * and login the user if OK.
367  *
368  * returns:
369  *      UPAP_AUTHNAK: Authentication failed.
370  *      UPAP_AUTHACK: Authentication succeeded.
371  * In either case, msg points to an appropriate message.
372  */
373 int
374 check_passwd(unit, auser, userlen, apasswd, passwdlen, msg, msglen)
375     int unit;
376     char *auser;
377     int userlen;
378     char *apasswd;
379     int passwdlen;
380     char **msg;
381     int *msglen;
382 {
383     int ret;
384     char *filename;
385     FILE *f;
386     struct wordlist *addrs;
387     char passwd[256], user[256];
388     char secret[MAXWORDLEN];
389     static int attempts = 0;
390
391     /*
392      * Make copies of apasswd and auser, then null-terminate them.
393      */
394     BCOPY(apasswd, passwd, passwdlen);
395     passwd[passwdlen] = '\0';
396     BCOPY(auser, user, userlen);
397     user[userlen] = '\0';
398
399     /*
400      * Open the file of upap secrets and scan for a suitable secret
401      * for authenticating this user.
402      */
403     filename = _PATH_UPAPFILE;
404     addrs = NULL;
405     ret = UPAP_AUTHACK;
406     f = fopen(filename, "r");
407     if (f == NULL) {
408         if (!uselogin) {
409             syslog(LOG_ERR, "Can't open PAP password file %s: %m", filename);
410             ret = UPAP_AUTHNAK;
411         }
412
413     } else {
414         check_access(f, filename);
415         if (scan_authfile(f, user, our_name, secret, &addrs, filename) < 0
416             || (secret[0] != 0 && (cryptpap || strcmp(passwd, secret) != 0)
417                 && strcmp(crypt(passwd, secret), secret) != 0)) {
418             syslog(LOG_WARNING, "PAP authentication failure for %s", user);
419             ret = UPAP_AUTHNAK;
420         }
421         fclose(f);
422     }
423
424     if (uselogin && ret == UPAP_AUTHACK) {
425         ret = login(user, passwd, msg, msglen);
426         if (ret == UPAP_AUTHNAK) {
427             syslog(LOG_WARNING, "PAP login failure for %s", user);
428         }
429     }
430
431     if (ret == UPAP_AUTHNAK) {
432         *msg = "Login incorrect";
433         *msglen = strlen(*msg);
434         /*
435          * Frustrate passwd stealer programs.
436          * Allow 10 tries, but start backing off after 3 (stolen from login).
437          * On 10'th, drop the connection.
438          */
439         if (attempts++ >= 10) {
440             syslog(LOG_WARNING, "%d LOGIN FAILURES ON %s, %s",
441                    attempts, devnam, user);
442             quit();
443         }
444         if (attempts > 3)
445             sleep((u_int) (attempts - 3) * 5);
446         if (addrs != NULL)
447             free_wordlist(addrs);
448
449     } else {
450         attempts = 0;                   /* Reset count */
451         *msg = "Login ok";
452         *msglen = strlen(*msg);
453         if (addresses[unit] != NULL)
454             free_wordlist(addresses[unit]);
455         addresses[unit] = addrs;
456     }
457
458     return ret;
459 }
460
461
462 /*
463  * login - Check the user name and password against the system
464  * password database, and login the user if OK.
465  *
466  * returns:
467  *      UPAP_AUTHNAK: Login failed.
468  *      UPAP_AUTHACK: Login succeeded.
469  * In either case, msg points to an appropriate message.
470  */
471 static int
472 login(user, passwd, msg, msglen)
473     char *user;
474     char *passwd;
475     char **msg;
476     int *msglen;
477 {
478     struct passwd *pw;
479     char *epasswd;
480     char *tty;
481
482 #ifdef HAS_SHADOW
483     struct spwd *spwd;
484     struct spwd *getspnam();
485 #endif
486
487     if ((pw = getpwnam(user)) == NULL) {
488         return (UPAP_AUTHNAK);
489     }
490
491 #ifdef HAS_SHADOW
492     if ((spwd = getspnam(user)) == NULL) {
493         pw->pw_passwd = "";
494     } else {
495         pw->pw_passwd = spwd->sp_pwdp;
496     }
497 #endif
498
499     /*
500      * XXX If no passwd, let them login without one.
501      */
502     if (pw->pw_passwd == '\0') {
503         return (UPAP_AUTHACK);
504     }
505
506 #ifdef HAS_SHADOW
507     if ((pw->pw_passwd && pw->pw_passwd[0] == '@'
508          && pw_auth (pw->pw_passwd+1, pw->pw_name, PW_PPP, NULL))
509         || !valid (passwd, pw)) {
510         return (UPAP_AUTHNAK);
511     }
512 #else
513     epasswd = crypt(passwd, pw->pw_passwd);
514     if (strcmp(epasswd, pw->pw_passwd)) {
515         return (UPAP_AUTHNAK);
516     }
517 #endif
518
519     syslog(LOG_INFO, "user %s logged in", user);
520
521     /*
522      * Write a wtmp entry for this user.
523      */
524     tty = devnam;
525     if (strncmp(tty, "/dev/", 5) == 0)
526         tty += 5;
527     logwtmp(tty, user, "");             /* Add wtmp login entry */
528     logged_in = TRUE;
529
530     return (UPAP_AUTHACK);
531 }
532
533 /*
534  * logout - Logout the user.
535  */
536 static void
537 logout()
538 {
539     char *tty;
540
541     tty = devnam;
542     if (strncmp(tty, "/dev/", 5) == 0)
543         tty += 5;
544     logwtmp(tty, "", "");               /* Wipe out wtmp logout entry */
545     logged_in = FALSE;
546 }
547
548
549 /*
550  * null_login - Check if a username of "" and a password of "" are
551  * acceptable, and iff so, set the list of acceptable IP addresses
552  * and return 1.
553  */
554 static int
555 null_login(unit)
556     int unit;
557 {
558     char *filename;
559     FILE *f;
560     int i, ret;
561     struct wordlist *addrs;
562     char secret[MAXWORDLEN];
563
564     /*
565      * Open the file of upap secrets and scan for a suitable secret.
566      * We don't accept a wildcard client.
567      */
568     filename = _PATH_UPAPFILE;
569     addrs = NULL;
570     f = fopen(filename, "r");
571     if (f == NULL)
572         return 0;
573     check_access(f, filename);
574
575     i = scan_authfile(f, "", our_name, secret, &addrs, filename);
576     ret = i >= 0 && (i & NONWILD_CLIENT) != 0 && secret[0] == 0;
577
578     if (ret) {
579         if (addresses[unit] != NULL)
580             free_wordlist(addresses[unit]);
581         addresses[unit] = addrs;
582     }
583
584     fclose(f);
585     return ret;
586 }
587
588
589 /*
590  * get_upap_passwd - get a password for authenticating ourselves with
591  * our peer using PAP.  Returns 1 on success, 0 if no suitable password
592  * could be found.
593  */
594 static int
595 get_upap_passwd()
596 {
597     char *filename;
598     FILE *f;
599     struct wordlist *addrs;
600     char secret[MAXWORDLEN];
601
602     filename = _PATH_UPAPFILE;
603     addrs = NULL;
604     f = fopen(filename, "r");
605     if (f == NULL)
606         return 0;
607     check_access(f, filename);
608     if (scan_authfile(f, user, remote_name, secret, NULL, filename) < 0)
609         return 0;
610     strncpy(passwd, secret, MAXSECRETLEN);
611     passwd[MAXSECRETLEN-1] = 0;
612     return 1;
613 }
614
615
616 /*
617  * have_upap_secret - check whether we have a PAP file with any
618  * secrets that we could possibly use for authenticating the peer.
619  */
620 static int
621 have_upap_secret()
622 {
623     FILE *f;
624     int ret;
625     char *filename;
626
627     filename = _PATH_UPAPFILE;
628     f = fopen(filename, "r");
629     if (f == NULL)
630         return 0;
631
632     ret = scan_authfile(f, NULL, our_name, NULL, NULL, filename);
633     fclose(f);
634     if (ret < 0)
635         return 0;
636
637     return 1;
638 }
639
640
641 /*
642  * have_chap_secret - check whether we have a CHAP file with a
643  * secret that we could possibly use for authenticating `client'
644  * on `server'.  Either can be the null string, meaning we don't
645  * know the identity yet.
646  */
647 static int
648 have_chap_secret(client, server)
649     char *client;
650     char *server;
651 {
652     FILE *f;
653     int ret;
654     char *filename;
655
656     filename = _PATH_CHAPFILE;
657     f = fopen(filename, "r");
658     if (f == NULL)
659         return 0;
660
661     if (client[0] == 0)
662         client = NULL;
663     else if (server[0] == 0)
664         server = NULL;
665
666     ret = scan_authfile(f, client, server, NULL, NULL, filename);
667     fclose(f);
668     if (ret < 0)
669         return 0;
670
671     return 1;
672 }
673
674
675 /*
676  * get_secret - open the CHAP secret file and return the secret
677  * for authenticating the given client on the given server.
678  * (We could be either client or server).
679  */
680 int
681 get_secret(unit, client, server, secret, secret_len, save_addrs)
682     int unit;
683     char *client;
684     char *server;
685     char *secret;
686     int *secret_len;
687     int save_addrs;
688 {
689     FILE *f;
690     int ret, len;
691     char *filename;
692     struct wordlist *addrs;
693     char secbuf[MAXWORDLEN];
694
695     filename = _PATH_CHAPFILE;
696     addrs = NULL;
697     secbuf[0] = 0;
698
699     f = fopen(filename, "r");
700     if (f == NULL) {
701         syslog(LOG_ERR, "Can't open chap secret file %s: %m", filename);
702         return 0;
703     }
704     check_access(f, filename);
705
706     ret = scan_authfile(f, client, server, secbuf, &addrs, filename);
707     fclose(f);
708     if (ret < 0)
709         return 0;
710
711     if (save_addrs) {
712         if (addresses[unit] != NULL)
713             free_wordlist(addresses[unit]);
714         addresses[unit] = addrs;
715     }
716
717     len = strlen(secbuf);
718     if (len > MAXSECRETLEN) {
719         syslog(LOG_ERR, "Secret for %s on %s is too long", client, server);
720         len = MAXSECRETLEN;
721     }
722     BCOPY(secbuf, secret, len);
723     *secret_len = len;
724
725     return 1;
726 }
727
728 /*
729  * auth_ip_addr - check whether the peer is authorized to use
730  * a given IP address.  Returns 1 if authorized, 0 otherwise.
731  */
732 int
733 auth_ip_addr(unit, addr)
734     int unit;
735     u_int32_t addr;
736 {
737     u_int32_t a, mask;
738     int accept;
739     char *ptr_word, *ptr_mask;
740     struct hostent *hp;
741     struct netent *np;
742     struct wordlist *addrs;
743
744     /* don't allow loopback or multicast address */
745     if (bad_ip_adrs(addr))
746         return 0;
747
748     if ((addrs = addresses[unit]) == NULL)
749         return 1;               /* no restriction */
750
751     for (; addrs != NULL; addrs = addrs->next) {
752         /* "-" means no addresses authorized */
753         ptr_word = addrs->word;
754         if (strcmp(ptr_word, "-") == 0)
755             break;
756
757         accept = 1;
758         if (*ptr_word == '!') {
759             accept = 0;
760             ++ptr_word;
761         }
762
763         mask = ~ (u_int32_t) 0;
764         ptr_mask = strchr (ptr_word, '/');
765         if (ptr_mask != NULL) {
766             int bit_count;
767
768             bit_count = (int) strtol (ptr_mask+1, (char **) 0, 10);
769             if (bit_count <= 0 || bit_count > 32) {
770                 syslog (LOG_WARNING,
771                         "invalid address length %s in auth. address list",
772                         ptr_mask);
773                 continue;
774             }
775             *ptr_mask = '\0';
776             mask <<= 32 - bit_count;
777         }
778
779         hp = gethostbyname(ptr_word);
780         if (hp != NULL && hp->h_addrtype == AF_INET) {
781             a    = *(u_int32_t *)hp->h_addr;
782             mask = ~ (u_int32_t) 0;     /* are we sure we want this? */
783         } else {
784             np = getnetbyname (ptr_word);
785             if (np != NULL && np->n_addrtype == AF_INET)
786                 a = htonl (*(u_int32_t *)np->n_net);
787             else
788                 a = inet_addr (ptr_word);
789         }
790
791         if (ptr_mask != NULL)
792             *ptr_mask = '/';
793
794         if (a == -1L)
795             syslog (LOG_WARNING,
796                     "unknown host %s in auth. address list",
797                     addrs->word);
798         else
799             if (((addr ^ a) & mask) == 0)
800                 return accept;
801     }
802     return 0;                   /* not in list => can't have it */
803 }
804
805 /*
806  * bad_ip_adrs - return 1 if the IP address is one we don't want
807  * to use, such as an address in the loopback net or a multicast address.
808  * addr is in network byte order.
809  */
810 int
811 bad_ip_adrs(addr)
812     u_int32_t addr;
813 {
814     addr = ntohl(addr);
815     return (addr >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET
816         || IN_MULTICAST(addr) || IN_BADCLASS(addr);
817 }
818
819 /*
820  * check_access - complain if a secret file has too-liberal permissions.
821  */
822 void
823 check_access(f, filename)
824     FILE *f;
825     char *filename;
826 {
827     struct stat sbuf;
828
829     if (fstat(fileno(f), &sbuf) < 0) {
830         syslog(LOG_WARNING, "cannot stat secret file %s: %m", filename);
831     } else if ((sbuf.st_mode & (S_IRWXG | S_IRWXO)) != 0) {
832         syslog(LOG_WARNING, "Warning - secret file %s has world and/or group access", filename);
833     }
834 }
835
836
837 /*
838  * scan_authfile - Scan an authorization file for a secret suitable
839  * for authenticating `client' on `server'.  The return value is -1
840  * if no secret is found, otherwise >= 0.  The return value has
841  * NONWILD_CLIENT set if the secret didn't have "*" for the client, and
842  * NONWILD_SERVER set if the secret didn't have "*" for the server.
843  * Any following words on the line (i.e. address authorization
844  * info) are placed in a wordlist and returned in *addrs.  
845  */
846 static int
847 scan_authfile(f, client, server, secret, addrs, filename)
848     FILE *f;
849     char *client;
850     char *server;
851     char *secret;
852     struct wordlist **addrs;
853     char *filename;
854 {
855     int newline, xxx;
856     int got_flag, best_flag;
857     FILE *sf;
858     struct wordlist *ap, *addr_list, *addr_last;
859     char word[MAXWORDLEN];
860     char atfile[MAXWORDLEN];
861
862     if (addrs != NULL)
863         *addrs = NULL;
864     addr_list = NULL;
865     if (!getword(f, word, &newline, filename))
866         return -1;              /* file is empty??? */
867     newline = 1;
868     best_flag = -1;
869     for (;;) {
870         /*
871          * Skip until we find a word at the start of a line.
872          */
873         while (!newline && getword(f, word, &newline, filename))
874             ;
875         if (!newline)
876             break;              /* got to end of file */
877
878         /*
879          * Got a client - check if it's a match or a wildcard.
880          */
881         got_flag = 0;
882         if (client != NULL && strcmp(word, client) != 0 && !ISWILD(word)) {
883             newline = 0;
884             continue;
885         }
886         if (!ISWILD(word))
887             got_flag = NONWILD_CLIENT;
888
889         /*
890          * Now get a server and check if it matches.
891          */
892         if (!getword(f, word, &newline, filename))
893             break;
894         if (newline)
895             continue;
896         if (server != NULL && strcmp(word, server) != 0 && !ISWILD(word))
897             continue;
898         if (!ISWILD(word))
899             got_flag |= NONWILD_SERVER;
900
901         /*
902          * Got some sort of a match - see if it's better than what
903          * we have already.
904          */
905         if (got_flag <= best_flag)
906             continue;
907
908         /*
909          * Get the secret.
910          */
911         if (!getword(f, word, &newline, filename))
912             break;
913         if (newline)
914             continue;
915
916         /*
917          * Special syntax: @filename means read secret from file.
918          */
919         if (word[0] == '@') {
920             strcpy(atfile, word+1);
921             if ((sf = fopen(atfile, "r")) == NULL) {
922                 syslog(LOG_WARNING, "can't open indirect secret file %s",
923                        atfile);
924                 continue;
925             }
926             check_access(sf, atfile);
927             if (!getword(sf, word, &xxx, atfile)) {
928                 syslog(LOG_WARNING, "no secret in indirect secret file %s",
929                        atfile);
930                 fclose(sf);
931                 continue;
932             }
933             fclose(sf);
934         }
935         if (secret != NULL)
936             strcpy(secret, word);
937                 
938         best_flag = got_flag;
939
940         /*
941          * Now read address authorization info and make a wordlist.
942          */
943         if (addr_list)
944             free_wordlist(addr_list);
945         addr_list = addr_last = NULL;
946         for (;;) {
947             if (!getword(f, word, &newline, filename) || newline)
948                 break;
949             ap = (struct wordlist *) malloc(sizeof(struct wordlist)
950                                             + strlen(word));
951             if (ap == NULL)
952                 novm("authorized addresses");
953             ap->next = NULL;
954             strcpy(ap->word, word);
955             if (addr_list == NULL)
956                 addr_list = ap;
957             else
958                 addr_last->next = ap;
959             addr_last = ap;
960         }
961         if (!newline)
962             break;
963     }
964
965     if (addrs != NULL)
966         *addrs = addr_list;
967     else if (addr_list != NULL)
968         free_wordlist(addr_list);
969
970     return best_flag;
971 }
972
973 /*
974  * free_wordlist - release memory allocated for a wordlist.
975  */
976 static void
977 free_wordlist(wp)
978     struct wordlist *wp;
979 {
980     struct wordlist *next;
981
982     while (wp != NULL) {
983         next = wp->next;
984         free(wp);
985         wp = next;
986     }
987 }