libbb/pw_encrypt.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Utility routines.
   4  *
   5  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
   6  *
   7  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   8  */
   9 #include "libbb.h"
  10
  11 /* static const uint8_t ascii64[] ALIGN1 =
  12  * "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  13  */
  14
  15 static int i64c(int i)
  16 {
  17         i &= 0x3f;
  18         if (i == 0)
  19                 return '.';
  20         if (i == 1)
  21                 return '/';
  22         if (i < 12)
  23                 return ('0' - 2 + i);
  24         if (i < 38)
  25                 return ('A' - 12 + i);
  26         return ('a' - 38 + i);
  27 }
  28
  29 int FAST_FUNC crypt_make_salt(char *p, int cnt /*, int x */)
  30 {
  31         /* was: x += ... */
  32         unsigned x = getpid() + monotonic_us();
  33         do {
  34                 /* x = (x*1664525 + 1013904223) % 2^32 generator is lame
  35                  * (low-order bit is not "random", etc...),
  36                  * but for our purposes it is good enough */
  37                 x = x*1664525 + 1013904223;
  38                 /* BTW, Park and Miller's "minimal standard generator" is
  39                  * x = x*16807 % ((2^31)-1)
  40                  * It has no problem with visibly alternating lowest bit
  41                  * but is also weak in cryptographic sense + needs div,
  42                  * which needs more code (and slower) on many CPUs */
  43                 *p++ = i64c(x >> 16);
  44                 *p++ = i64c(x >> 22);
  45         } while (--cnt);
  46         *p = '\0';
  47         return x;
  48 }
  49
  50 char* FAST_FUNC crypt_make_pw_salt(char salt[MAX_PW_SALT_LEN], const char *algo)
  51 {
  52         int len = 2/2;
  53         char *salt_ptr = salt;
  54
  55         /* Standard chpasswd uses uppercase algos ("MD5", not "md5").
  56          * Need to be case-insensitive in the code below.
  57          */
  58         if ((algo[0]|0x20) != 'd') { /* not des */
  59                 len = 8/2; /* so far assuming md5 */
  60                 *salt_ptr++ = '$';
  61                 *salt_ptr++ = '1';
  62                 *salt_ptr++ = '$';
  63 #if !ENABLE_USE_BB_CRYPT || ENABLE_USE_BB_CRYPT_SHA
  64                 if ((algo[0]|0x20) == 's') { /* sha */
  65                         salt[1] = '5' + (strcasecmp(algo, "sha512") == 0);
  66                         len = 16/2;
  67                 }
  68 #endif
  69         }
  70         crypt_make_salt(salt_ptr, len);
  71         return salt_ptr;
  72 }
  73
  74 #if ENABLE_USE_BB_CRYPT
  75
  76 static char*
  77 to64(char *s, unsigned v, int n)
  78 {
  79         while (--n >= 0) {
  80                 /* *s++ = ascii64[v & 0x3f]; */
  81                 *s++ = i64c(v);
  82                 v >>= 6;
  83         }
  84         return s;
  85 }
  86
  87 /*
  88  * DES and MD5 crypt implementations are taken from uclibc.
  89  * They were modified to not use static buffers.
  90  */
  91
  92 #include "pw_encrypt_des.c"
  93 #include "pw_encrypt_md5.c"
  94 #if ENABLE_USE_BB_CRYPT_SHA
  95 #include "pw_encrypt_sha.c"
  96 #endif
  97
  98 /* Other advanced crypt ids (TODO?): */
  99 /* $2$ or $2a$: Blowfish */
 100
 101 static struct const_des_ctx *des_cctx;
 102 static struct des_ctx *des_ctx;
 103
 104 /* my_crypt returns malloc'ed data */
 105 static char *my_crypt(const char *key, const char *salt)
 106 {
 107         /* MD5 or SHA? */
 108         if (salt[0] == '$' && salt[1] && salt[2] == '$') {
 109                 if (salt[1] == '1')
 110                         return md5_crypt(xzalloc(MD5_OUT_BUFSIZE), (unsigned char*)key, (unsigned char*)salt);
 111 #if ENABLE_USE_BB_CRYPT_SHA
 112                 if (salt[1] == '5' || salt[1] == '6')
 113                         return sha_crypt((char*)key, (char*)salt);
 114 #endif
 115         }
 116
 117         if (!des_cctx)
 118                 des_cctx = const_des_init();
 119         des_ctx = des_init(des_ctx, des_cctx);
 120         return des_crypt(des_ctx, xzalloc(DES_OUT_BUFSIZE), (unsigned char*)key, (unsigned char*)salt);
 121 }
 122
 123 /* So far nobody wants to have it public */
 124 static void my_crypt_cleanup(void)
 125 {
 126         free(des_cctx);
 127         free(des_ctx);
 128         des_cctx = NULL;
 129         des_ctx = NULL;
 130 }
 131
 132 char* FAST_FUNC pw_encrypt(const char *clear, const char *salt, int cleanup)
 133 {
 134         char *encrypted;
 135
 136         encrypted = my_crypt(clear, salt);
 137
 138         if (cleanup)
 139                 my_crypt_cleanup();
 140
 141         return encrypted;
 142 }
 143
 144 #else /* if !ENABLE_USE_BB_CRYPT */
 145
 146 char* FAST_FUNC pw_encrypt(const char *clear, const char *salt, int cleanup)
 147 {
 148         char *s;
 149
 150         s = crypt(clear, salt);
 151         /*
 152          * glibc used to return "" on malformed salts (for example, ""),
 153          * but since 2.17 it returns NULL.
 154          */
 155         return xstrdup(s ? s : "");
 156 }
 157
 158 #endif