HP's cpp apparently can't handle whitespace before #include
[rsync.git] / authenticate.c
1 /* -*- c-file-style: "linux"; -*-
2    
3    Copyright (C) 1998-2000 by Andrew Tridgell 
4    
5    This program is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published by
7    the Free Software Foundation; either version 2 of the License, or
8    (at your option) any later version.
9    
10    This program is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.
14    
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software
17    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19
20 /* support rsync authentication */
21 #include "rsync.h"
22
23 /***************************************************************************
24 encode a buffer using base64 - simple and slow algorithm. null terminates
25 the result.
26   ***************************************************************************/
27 static void base64_encode(char *buf, int len, char *out)
28 {
29         char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
30         int bit_offset, byte_offset, idx, i;
31         unsigned char *d = (unsigned char *)buf;
32         int bytes = (len*8 + 5)/6;
33
34         memset(out, 0, bytes+1);
35
36         for (i=0;i<bytes;i++) {
37                 byte_offset = (i*6)/8;
38                 bit_offset = (i*6)%8;
39                 if (bit_offset < 3) {
40                         idx = (d[byte_offset] >> (2-bit_offset)) & 0x3F;
41                 } else {
42                         idx = (d[byte_offset] << (bit_offset-2)) & 0x3F;
43                         if (byte_offset+1 < len) {
44                                 idx |= (d[byte_offset+1] >> (8-(bit_offset-2)));
45                         }
46                 }
47                 out[i] = b64[idx];
48         }
49 }
50
51 /* create a 16 byte challenge buffer */
52 static void gen_challenge(char *addr, char *challenge)
53 {
54         char input[32];
55         struct timeval tv;
56
57         memset(input, 0, sizeof(input));
58
59         strlcpy((char *)input, addr, 17);
60         sys_gettimeofday(&tv);
61         SIVAL(input, 16, tv.tv_sec);
62         SIVAL(input, 20, tv.tv_usec);
63         SIVAL(input, 24, getpid());
64
65         sum_init();
66         sum_update(input, sizeof(input));
67         sum_end(challenge);
68 }
69
70
71 /* return the secret for a user from the sercret file. maximum length
72    is len. null terminate it */
73 static int get_secret(int module, char *user, char *secret, int len)
74 {
75         char *fname = lp_secrets_file(module);
76         int fd, found=0;
77         char line[MAXPATHLEN];
78         char *p, *pass=NULL;
79         STRUCT_STAT st;
80         int ok = 1;
81         extern int am_root;
82
83         if (!fname || !*fname) return 0;
84
85         fd = open(fname,O_RDONLY);
86         if (fd == -1) return 0;
87
88         if (do_stat(fname, &st) == -1) {
89                 rsyserr(FERROR, errno, "stat(%s)", fname);
90                 ok = 0;
91         } else if (lp_strict_modes(module)) {
92                 if ((st.st_mode & 06) != 0) {
93                         rprintf(FERROR,"secrets file must not be other-accessible (see strict modes option)\n");
94                         ok = 0;
95                 } else if (am_root && (st.st_uid != 0)) {
96                         rprintf(FERROR,"secrets file must be owned by root when running as root (see strict modes)\n");
97                         ok = 0;
98                 }
99         }
100         if (!ok) {
101                 rprintf(FERROR,"continuing without secrets file\n");
102                 close(fd);
103                 return 0;
104         }
105
106         while (!found) {
107                 int i = 0;
108                 memset(line, 0, sizeof(line));
109                 while (i<(sizeof(line)-1)) {
110                         if (read(fd, &line[i], 1) != 1) {
111                                 memset(line, 0, sizeof(line));
112                                 close(fd);
113                                 return 0;
114                         }
115                         if (line[i] == '\r') continue;
116                         if (line[i] == '\n') break;
117                         i++;
118                 }
119                 line[i] = 0;
120                 if (line[0] == '#') continue;
121                 p = strchr(line,':');
122                 if (!p) continue;
123                 *p = 0;
124                 if (strcmp(user, line)) continue;
125                 pass = p+1;
126                 found = 1;
127         }
128
129         close(fd);
130         if (!found) return 0;
131
132         strlcpy(secret, pass, len);
133         return 1;
134 }
135
136 static char *getpassf(char *filename)
137 {
138         char buffer[100];
139         int fd=0;
140         STRUCT_STAT st;
141         int ok = 1;
142         extern int am_root;
143         char *envpw=getenv("RSYNC_PASSWORD");
144
145         if (!filename) return NULL;
146
147         if ( (fd=open(filename,O_RDONLY)) == -1) {
148                 rsyserr(FERROR, errno, "could not open password file \"%s\"",filename);
149                 if (envpw) rprintf(FERROR,"falling back to RSYNC_PASSWORD environment variable.\n");    
150                 return NULL;
151         }
152         
153         if (do_stat(filename, &st) == -1) {
154                 rsyserr(FERROR, errno, "stat(%s)", filename);
155                 ok = 0;
156         } else if ((st.st_mode & 06) != 0) {
157                 rprintf(FERROR,"password file must not be other-accessible\n");
158                 ok = 0;
159         } else if (am_root && (st.st_uid != 0)) {
160                 rprintf(FERROR,"password file must be owned by root when running as root\n");
161                 ok = 0;
162         }
163         if (!ok) {
164                 rprintf(FERROR,"continuing without password file\n");
165                 if (envpw) rprintf(FERROR,"using RSYNC_PASSWORD environment variable.\n");
166                 close(fd);
167                 return NULL;
168         }
169
170         if (envpw) rprintf(FERROR,"RSYNC_PASSWORD environment variable ignored\n");
171
172         buffer[sizeof(buffer)-1]='\0';
173         if (read(fd,buffer,sizeof(buffer)-1) > 0)
174         {
175                 char *p = strtok(buffer,"\n\r");
176                 close(fd);
177                 if (p) p = strdup(p);
178                 return p;
179         }       
180
181         return NULL;
182 }
183
184 /* generate a 16 byte hash from a password and challenge */
185 static void generate_hash(char *in, char *challenge, char *out)
186 {
187         char buf[16];
188
189         sum_init();
190         sum_update(in, strlen(in));
191         sum_update(challenge, strlen(challenge));
192         sum_end(buf);
193
194         base64_encode(buf, 16, out);
195 }
196
197 /* possible negotiate authentication with the client. Use "leader" to
198    start off the auth if necessary 
199
200    return NULL if authentication failed
201
202    return "" if anonymous access
203
204    otherwise return username
205 */
206 char *auth_server(int fd, int module, char *addr, char *leader)
207 {
208         char *users = lp_auth_users(module);
209         char challenge[16];
210         char b64_challenge[30];
211         char line[MAXPATHLEN];
212         static char user[100];
213         char secret[100];
214         char pass[30];
215         char pass2[30];
216         char *tok;
217
218         /* if no auth list then allow anyone in! */
219         if (!users || !*users) return "";
220
221         gen_challenge(addr, challenge);
222         
223         base64_encode(challenge, 16, b64_challenge);
224
225         io_printf(fd,"%s%s\n", leader, b64_challenge);
226
227         if (!read_line(fd, line, sizeof(line)-1)) {
228                 return NULL;
229         }
230
231         memset(user, 0, sizeof(user));
232         memset(pass, 0, sizeof(pass));
233
234         if (sscanf(line,"%99s %29s", user, pass) != 2) {
235                 return NULL;
236         }
237         
238         users = strdup(users);
239         if (!users) return NULL;
240
241         for (tok=strtok(users," ,\t"); tok; tok = strtok(NULL," ,\t")) {
242                 if (fnmatch(tok, user, 0) == 0) break;
243         }
244         free(users);
245
246         if (!tok) {
247                 return NULL;
248         }
249         
250         memset(secret, 0, sizeof(secret));
251         if (!get_secret(module, user, secret, sizeof(secret)-1)) {
252                 memset(secret, 0, sizeof(secret));
253                 return NULL;
254         }
255
256         generate_hash(secret, b64_challenge, pass2);
257         memset(secret, 0, sizeof(secret));
258         
259         if (strcmp(pass, pass2) == 0)
260                 return user;
261
262         return NULL;
263 }
264
265
266 void auth_client(int fd, char *user, char *challenge)
267 {
268         char *pass;
269         char pass2[30];
270         extern char *password_file;
271
272         if (!user || !*user) return;
273
274         if (!(pass=getpassf(password_file)) && !(pass=getenv("RSYNC_PASSWORD"))) {
275                 /* XXX: cyeoh says that getpass is deprecated, because
276                    it may return a truncated password on some systems,
277                    and it is not in the LSB. */
278                 pass = getpass("Password: ");
279         }
280
281         if (!pass || !*pass) {
282                 pass = "";
283         }
284
285         generate_hash(pass, challenge, pass2);
286         io_printf(fd, "%s %s\n", user, pass2);
287 }
288
289