src/kauth/client.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afsconfig.h>
  11 #include <afs/param.h>
  12
  13 #include <afs/stds.h>
  14 #include <afs/pthread_glock.h>
  15 #include <stdio.h>
  16 #ifdef AFS_NT40_ENV
  17 #include <winsock2.h>
  18 #include <crypt.h>
  19 #endif
  20 #include <string.h>
  21 #ifdef HAVE_UNISTD_H
  22 #if !defined(__USE_XOPEN)
  23 #define __USE_XOPEN
  24 #endif
  25 #include <unistd.h>
  26 #endif
  27 #include <afs/cellconfig.h>
  28 #include <afs/auth.h>
  29 #include <afs/afsutil.h>
  30 #include <des.h>
  31 #include <des_prototypes.h>
  32 #include "kauth.h"
  33 #include "kautils.h"
  34
  35
  36 /* This defines the Andrew string_to_key function.  It accepts a password
  37    string as input and converts it via a one-way encryption algorithm to a DES
  38    encryption key.  It is compatible with the original Andrew authentication
  39    service password database. */
  40
  41 static void
  42 Andrew_StringToKey(char *str, char *cell,       /* cell for password */
  43                    struct ktc_encryptionKey *key)
  44 {
  45     char password[8 + 1];       /* crypt's limit is 8 chars anyway */
  46     int i;
  47     int passlen;
  48
  49     memset(key, 0, sizeof(struct ktc_encryptionKey));
  50
  51     strncpy(password, cell, 8);
  52     passlen = strlen(str);
  53     if (passlen > 8)
  54         passlen = 8;
  55
  56     for (i = 0; i < passlen; i++)
  57         password[i] ^= str[i];
  58
  59     for (i = 0; i < 8; i++)
  60         if (password[i] == '\0')
  61             password[i] = 'X';
  62
  63     /* crypt only considers the first 8 characters of password but for some
  64      * reason returns eleven characters of result (plus the two salt chars). */
  65     strncpy((char *)key, (char *)crypt(password, "p1") + 2,
  66             sizeof(struct ktc_encryptionKey));
  67
  68     /* parity is inserted into the LSB so leftshift each byte up one bit.  This
  69      * allows ascii characters with a zero MSB to retain as much significance
  70      * as possible. */
  71     {
  72         char *keybytes = (char *)key;
  73         unsigned int temp;
  74
  75         for (i = 0; i < 8; i++) {
  76             temp = (unsigned int)keybytes[i];
  77             keybytes[i] = (unsigned char)(temp << 1);
  78         }
  79     }
  80     des_fixup_key_parity(ktc_to_cblock(key));
  81 }
  82
  83 static void
  84 StringToKey(char *str, char *cell,      /* cell for password */
  85             struct ktc_encryptionKey *key)
  86 {
  87     des_key_schedule schedule;
  88     unsigned char temp_key[8];
  89     char ivec[8];
  90     char password[BUFSIZ];
  91     int passlen;
  92
  93     strncpy(password, str, sizeof(password));
  94     if ((passlen = strlen(password)) < sizeof(password) - 1)
  95         strncat(password, cell, sizeof(password) - passlen);
  96     if ((passlen = strlen(password)) > sizeof(password))
  97         passlen = sizeof(password);
  98
  99     memcpy(ivec, "kerberos", 8);
 100     memcpy(temp_key, "kerberos", 8);
 101     des_fixup_key_parity(temp_key);
 102     des_key_sched(temp_key, schedule);
 103     des_cbc_cksum(charptr_to_cblockptr(password), charptr_to_cblockptr(ivec), passlen, schedule, charptr_to_cblockptr(ivec));
 104
 105     memcpy(temp_key, ivec, 8);
 106     des_fixup_key_parity(temp_key);
 107     des_key_sched(temp_key, schedule);
 108     des_cbc_cksum(charptr_to_cblockptr(password), ktc_to_cblockptr(key), passlen, schedule, charptr_to_cblockptr(ivec));
 109
 110     des_fixup_key_parity(ktc_to_cblock(key));
 111 }
 112
 113 void
 114 ka_StringToKey(char *str, char *cell,   /* cell for password */
 115                struct ktc_encryptionKey *key)
 116 {
 117     char realm[MAXKTCREALMLEN];
 118     afs_int32 code;
 119
 120     LOCK_GLOBAL_MUTEX;
 121     code = ka_CellToRealm(cell, realm, 0 /*local */ );
 122     if (code)                   /* just take his word for it */
 123         strncpy(realm, cell, sizeof(realm));
 124     else                        /* for backward compatibility */
 125         lcstring(realm, realm, sizeof(realm));
 126     if (strlen(str) > 8)
 127         StringToKey(str, realm, key);
 128     else
 129         Andrew_StringToKey(str, realm, key);
 130     UNLOCK_GLOBAL_MUTEX;
 131 }
 132
 133 /* This prints out a prompt and reads a string from the terminal, turning off
 134    echoing.  If verify is requested it requests that the string be entered
 135    again and the two strings are compared.  The string is then converted to a
 136    DES encryption key. */
 137
 138 /* Errors:
 139      KAREADPW - some error returned from read_pw_string
 140  */
 141
 142 afs_int32
 143 ka_ReadPassword(char *prompt, int verify, char *cell,
 144                 struct ktc_encryptionKey *key)
 145 {
 146     char password[BUFSIZ];
 147     afs_int32 code;
 148
 149     LOCK_GLOBAL_MUTEX;
 150     memset(key, 0, sizeof(struct ktc_encryptionKey));
 151     code = read_pw_string(password, sizeof(password), prompt, verify);
 152     if (code) {
 153         UNLOCK_GLOBAL_MUTEX;
 154         return KAREADPW;
 155     }
 156     if (strlen(password) == 0) {
 157         UNLOCK_GLOBAL_MUTEX;
 158         return KANULLPASSWORD;
 159     }
 160     ka_StringToKey(password, cell, key);
 161     UNLOCK_GLOBAL_MUTEX;
 162     return 0;
 163 }
 164
 165 /* This performs the backslash quoting defined by AC_ParseLoginName. */
 166
 167 static char
 168 map_char(char *str, int *ip)
 169 {
 170     char c = str[*ip];
 171     if (c == '\\') {
 172         c = str[++(*ip)];
 173         if ((c >= '0') && (c <= '7')) {
 174             c = c - '0';
 175             c = (c * 8) + (str[++(*ip)] - '0');
 176             c = (c * 8) + (str[++(*ip)] - '0');
 177         }
 178     }
 179     return c;
 180 }
 181
 182 /* This routine parses a string that might be entered by a user from the
 183    terminal.  It defines a syntax to allow a user to specify his identity in
 184    terms of his name, instance and cell with a single string.  These three
 185    output strings must be allocated by the caller to their maximum length.  The
 186    syntax is very simple: the first dot ('.') separates the name from the
 187    instance and the first atsign ('@') begins the cell name.  A backslash ('\')
 188    can be used to quote these special characters.  A backslash followed by an
 189    octal digit (zero through seven) introduces a three digit octal number which
 190    is interpreted as the ascii value of a single character. */
 191
 192 /* Errors:
 193      KABADARGUMENT - if no output parameters are specified.
 194      KABADNAME - if a component of the user name is too long or if a cell was
 195        specified but the cell parameter was null.
 196  */
 197
 198 afs_int32
 199 ka_ParseLoginName(char *login, char name[MAXKTCNAMELEN],
 200                   char inst[MAXKTCNAMELEN], char cell[MAXKTCREALMLEN])
 201 {
 202     int login_len = strlen(login);
 203     char rc, c;
 204     int i, j;
 205 #define READNAME 1
 206 #define READINST 2
 207 #define READCELL 3
 208     int reading;
 209
 210     if (!name)
 211         return KABADARGUMENT;
 212     strcpy(name, "");
 213     if (inst)
 214         strcpy(inst, "");
 215     if (cell)
 216         strcpy(cell, "");
 217     reading = READNAME;
 218     i = 0;
 219     j = 0;
 220     while (i < login_len) {
 221         rc = login[i];
 222         c = map_char(login, &i);
 223         switch (reading) {
 224         case READNAME:
 225             if (rc == '@') {
 226                 name[j] = 0;    /* finish name */
 227                 reading = READCELL;     /* but instance is null */
 228                 j = 0;
 229                 break;
 230             }
 231             if (inst && (rc == '.')) {
 232                 name[j] = 0;    /* finish name */
 233                 reading = READINST;
 234                 j = 0;
 235                 break;
 236             }
 237             if (j >= MAXKTCNAMELEN - 1)
 238                 return KABADNAME;
 239             name[j++] = c;
 240             break;
 241         case READINST:
 242             if (!inst)
 243                 return KABADNAME;
 244             if (rc == '@') {
 245                 inst[j] = 0;    /* finish name */
 246                 reading = READCELL;
 247                 j = 0;
 248                 break;
 249             }
 250             if (j >= MAXKTCNAMELEN - 1)
 251                 return KABADNAME;
 252             inst[j++] = c;
 253             break;
 254         case READCELL:
 255             if (!cell)
 256                 return KABADNAME;
 257             if (j >= MAXKTCREALMLEN - 1)
 258                 return KABADNAME;
 259             cell[j++] = c;
 260             break;
 261         }
 262         i++;
 263     }
 264     if (reading == READNAME)
 265         name[j] = 0;
 266     else if (reading == READINST) {
 267         if (inst)
 268             inst[j] = 0;
 269         else
 270             return KABADNAME;
 271     } else if (reading == READCELL) {
 272         if (cell)
 273             cell[j] = 0;
 274         else
 275             return KABADNAME;
 276     }
 277
 278     /* the cell is really an authDomain and therefore is really a realm */
 279     if (cell)
 280         ucstring(cell, cell, MAXKTCREALMLEN);
 281     return 0;
 282 }
 283
 284 /* Client side applications should call this to initialize error tables and
 285    connect to the correct CellServDB file. */
 286
 287 afs_int32
 288 ka_Init(int flags)
 289 {                               /* reserved for future use. */
 290     afs_int32 code;
 291     static int inited = 0;
 292
 293     LOCK_GLOBAL_MUTEX;
 294     if (inited) {
 295         UNLOCK_GLOBAL_MUTEX;
 296         return 0;
 297     }
 298     inited++;
 299     initialize_U_error_table();
 300     initialize_KA_error_table();
 301     initialize_RXK_error_table();
 302     initialize_KTC_error_table();
 303     initialize_ACFG_error_table();
 304     code = ka_CellConfig(AFSDIR_CLIENT_ETC_DIRPATH);
 305     UNLOCK_GLOBAL_MUTEX;
 306     if (code)
 307         return code;
 308     return 0;
 309 }
 310
 311 #ifdef MAIN
 312 int
 313 main(void)
 314 {
 315     struct ktc_encryptionKey key;
 316     int code;
 317     char line[256];
 318     char name[MAXKTCNAMELEN];
 319     char instance[MAXKTCNAMELEN];
 320     char cell[MAXKTCREALMLEN];
 321
 322     printf("Enter login:");
 323     fgets(line, 255, stdin);
 324     ka_ParseLoginName(line, name, instance, cell);
 325     printf("'%s' '%s' '%s'\n", name, instance, cell);
 326
 327 }
 328 #endif /* MAIN */