authenticate.c

   1 /*
   2    Copyright (C) Andrew Tridgell 1998
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 /* support rsync authentication */
  20 #include "rsync.h"
  21
  22 /***************************************************************************
  23 encode a buffer using base64 - simple and slow algorithm. null terminates
  24 the result.
  25   ***************************************************************************/
  26 static void base64_encode(char *buf, int len, char *out)
  27 {
  28         char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  29         int bit_offset, byte_offset, idx, i;
  30         unsigned char *d = (unsigned char *)buf;
  31         int bytes = (len*8 + 5)/6;
  32
  33         memset(out, 0, bytes+1);
  34
  35         for (i=0;i<bytes;i++) {
  36                 byte_offset = (i*6)/8;
  37                 bit_offset = (i*6)%8;
  38                 if (bit_offset < 3) {
  39                         idx = (d[byte_offset] >> (2-bit_offset)) & 0x3F;
  40                 } else {
  41                         idx = (d[byte_offset] << (bit_offset-2)) & 0x3F;
  42                         if (byte_offset+1 < len) {
  43                                 idx |= (d[byte_offset+1] >> (8-(bit_offset-2)));
  44                         }
  45                 }
  46                 out[i] = b64[idx];
  47         }
  48 }
  49
  50 /* create a 16 byte challenge buffer */
  51 static void gen_challenge(char *addr, char *challenge)
  52 {
  53         char input[32];
  54         struct timeval tv;
  55
  56         memset(input, 0, sizeof(input));
  57
  58         strlcpy((char *)input, addr, 16);
  59         gettimeofday(&tv, NULL);
  60         SIVAL(input, 16, tv.tv_sec);
  61         SIVAL(input, 20, tv.tv_usec);
  62         SIVAL(input, 24, getpid());
  63
  64         sum_init();
  65         sum_update(input, sizeof(input));
  66         sum_end(challenge);
  67 }
  68
  69
  70 /* return the secret for a user from the sercret file. maximum length
  71    is len. null terminate it */
  72 static int get_secret(int module, char *user, char *secret, int len)
  73 {
  74         char *fname = lp_secrets_file(module);
  75         int fd, found=0;
  76         char line[MAXPATHLEN];
  77         char *p, *pass=NULL;
  78
  79         if (!fname || !*fname) return 0;
  80
  81         fd = open(fname,O_RDONLY);
  82         if (fd == -1) return 0;
  83
  84         while (!found) {
  85                 int i = 0;
  86                 memset(line, 0, sizeof(line));
  87                 while (i<(sizeof(line)-1)) {
  88                         if (read(fd, &line[i], 1) != 1) {
  89                                 memset(line, 0, sizeof(line));
  90                                 close(fd);
  91                                 return 0;
  92                         }
  93                         if (line[i] == '\r') continue;
  94                         if (line[i] == '\n') break;
  95                         i++;
  96                 }
  97                 line[i] = 0;
  98                 if (line[0] == '#') continue;
  99                 p = strchr(line,':');
 100                 if (!p) continue;
 101                 *p = 0;
 102                 if (strcmp(user, line)) continue;
 103                 pass = p+1;
 104                 found = 1;
 105         }
 106
 107         close(fd);
 108         if (!found) return 0;
 109
 110         if (strlen(pass) > len-1) {
 111                 memset(line, 0, sizeof(line));
 112                 return 0;
 113         }
 114
 115         strcpy(secret, pass);
 116         return 1;
 117 }
 118
 119 /* generate a 16 byte hash from a password and challenge */
 120 void generate_hash(char *in, char *challenge, char *out)
 121 {
 122         char buf[16];
 123
 124         sum_init();
 125         sum_update(in, strlen(in));
 126         sum_update(challenge, strlen(challenge));
 127         sum_end(buf);
 128
 129         base64_encode(buf, 16, out);
 130 }
 131
 132 /* possible negotiate authentication with the client. Use "leader" to
 133    start off the auth if necessary */
 134 int auth_server(int fd, int module, char *addr, char *leader)
 135 {
 136         char *users = lp_auth_users(module);
 137         char challenge[16];
 138         char b64_challenge[30];
 139         char line[MAXPATHLEN];
 140         char user[100];
 141         char secret[100];
 142         char pass[30];
 143         char pass2[30];
 144         char *tok;
 145
 146         /* if no auth list then allow anyone in! */
 147         if (!users || !*users) return 1;
 148
 149         gen_challenge(addr, challenge);
 150
 151         base64_encode(challenge, 16, b64_challenge);
 152
 153         io_printf(fd,"%s%s\n", leader, b64_challenge);
 154
 155         if (!read_line(fd, line, sizeof(line)-1)) {
 156                 return 0;
 157         }
 158
 159         memset(user, 0, sizeof(user));
 160         memset(pass, 0, sizeof(pass));
 161
 162         if (sscanf(line,"%99s %29s", user, pass) != 2) {
 163                 return 0;
 164         }
 165
 166         users = strdup(users);
 167         if (!users) return 0;
 168
 169         for (tok=strtok(users," ,\t"); tok; tok = strtok(NULL," ,\t")) {
 170                 if (strcmp(tok, user) == 0) break;
 171         }
 172         free(users);
 173
 174         if (!tok) {
 175                 return 0;
 176         }
 177
 178         memset(secret, 0, sizeof(secret));
 179         if (!get_secret(module, user, secret, sizeof(secret)-1)) {
 180                 memset(secret, 0, sizeof(secret));
 181                 return 0;
 182         }
 183
 184         generate_hash(secret, b64_challenge, pass2);
 185         memset(secret, 0, sizeof(secret));
 186
 187         return (strcmp(pass, pass2) == 0);
 188 }
 189
 190
 191 void auth_client(int fd, char *user, char *challenge)
 192 {
 193         char *pass;
 194         char pass2[30];
 195
 196         if (!user || !*user) return;
 197
 198         if (!(pass=getenv("RSYNC_PASSWORD"))) {
 199                 pass = getpass("Password: ");
 200         }
 201
 202         if (!pass || !*pass) {
 203                 pass = "";
 204         }
 205
 206         generate_hash(pass, challenge, pass2);
 207
 208         io_printf(fd, "%s %s\n", user, pass2);
 209 }
 210