1: /*
    2:  * UFC-crypt: ultra fast crypt(3) implementation
    3:  *
    4:  * Copyright (C) 1991,1992,1993,1996,1997,2007 Free Software Foundation, Inc.
    5:  *
    6:  * The GNU C Library is free software; you can redistribute it and/or
    7:  * modify it under the terms of the GNU Lesser General Public
    8:  * License as published by the Free Software Foundation; either
    9:  * version 2.1 of the License, or (at your option) any later version.
   10:  *
   11:  * The GNU C Library is distributed in the hope that it will be useful,
   12:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   13:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   14:  * Lesser General Public License for more details.
   15:  *
   16:  * You should have received a copy of the GNU Lesser General Public
   17:  * License along with the GNU C Library; if not, write to the Free
   18:  * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   19:  * 02111-1307 USA.
   20:  *
   21:  * crypt entry points
   22:  *
   23:  * @(#)crypt-entry.c    1.2 12/20/96
   24:  *
   25:  */
   26: 
   27: #ifdef DEBUG
   28: #include <stdio.h>
   29: #endif
   30: #include <string.h>
   31: 
   32: #ifndef STATIC
   33: #define STATIC static
   34: #endif
   35: 
   36: #ifndef DOS
   37: #include "ufc-crypt.h"
   38: #else
   39: /*
   40:  * Thanks to greg%wind@plains.NoDak.edu (Greg W. Wettstein)
   41:  * for DOS patches
   42:  */
   43: #include "ufc.h"
   44: #endif
   45: #include "crypt.h"
   46: #include "crypt-private.h"
   47: 
   48: /* Prototypes for local functions.  */
   49: #if __STDC__ - 0
   50: #ifndef __GNU_LIBRARY__
   51: void _ufc_clearmem (char *start, int cnt);
   52: #else
   53: #define _ufc_clearmem(start, cnt)   memset(start, 0, cnt)
   54: #endif
   55: extern char *__md5_crypt_r (const char *key, const char *salt, char *buffer,
   56:                             int buflen);
   57: extern char *__md5_crypt (const char *key, const char *salt);
   58: extern char *__sha256_crypt_r (const char *key, const char *salt,
   59:                                char *buffer, int buflen);
   60: extern char *__sha256_crypt (const char *key, const char *salt);
   61: extern char *__sha512_crypt_r (const char *key, const char *salt,
   62:                                char *buffer, int buflen);
   63: extern char *__sha512_crypt (const char *key, const char *salt);
   64: #endif
   65: 
   66: /* Define our magic string to mark salt for MD5 encryption
   67:    replacement.  This is meant to be the same as for other MD5 based
   68:    encryption implementations.  */
   69: static const char md5_salt_prefix[] = "$1$";
   70: 
   71: /* Magic string for SHA256 encryption.  */
   72: static const char sha256_salt_prefix[] = "$5$";
   73: 
   74: /* Magic string for SHA512 encryption.  */
   75: static const char sha512_salt_prefix[] = "$6$";
   76: 
   77: /* For use by the old, non-reentrant routines (crypt/encrypt/setkey)  */
   78: extern struct crypt_data _ufc_foobar;
   79: 
   80: /*
   81:  * UNIX crypt function
   82:  */
   83: 
   84: char *
   85: __crypt_r (key, salt, data)
   86:      const char *key;
   87:      const char *salt;
   88:      struct crypt_data * __restrict data;
   89: {
   90:   ufc_long res[4];
   91:   char ktab[9];
   92:   ufc_long xx = 25; /* to cope with GCC long long compiler bugs */
   93: 
   94: #ifdef _LIBC
   95:   /* Try to find out whether we have to use MD5 encryption replacement.  */
   96:   if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0)
   97:     return __md5_crypt_r (key, salt, (char *) data,
   98:                           sizeof (struct crypt_data));
   99: 
  100:   /* Try to find out whether we have to use SHA256 encryption replacement.  */
  101:   if (strncmp (sha256_salt_prefix, salt, sizeof (sha256_salt_prefix) - 1) == 0)
  102:     return __sha256_crypt_r (key, salt, (char *) data,
  103:                              sizeof (struct crypt_data));
  104: 
  105:   /* Try to find out whether we have to use SHA512 encryption replacement.  */
  106:   if (strncmp (sha512_salt_prefix, salt, sizeof (sha512_salt_prefix) - 1) == 0)
  107:     return __sha512_crypt_r (key, salt, (char *) data,
  108:                              sizeof (struct crypt_data));
  109: #endif
  110: 
  111:   /*
  112:    * Hack DES tables according to salt
  113:    */
  114:   _ufc_setup_salt_r (salt, data);
  115: 
  116:   /*
  117:    * Setup key schedule
  118:    */
  119:   _ufc_clearmem (ktab, (int) sizeof (ktab));
  120:   (void) strncpy (ktab, key, 8);
  121:   _ufc_mk_keytab_r (ktab, data);
  122: 
  123:   /*
  124:    * Go for the 25 DES encryptions
  125:    */
  126:   _ufc_clearmem ((char*) res, (int) sizeof (res));
  127:   _ufc_doit_r (xx,  data, &res[0]);
  128: 
  129:   /*
  130:    * Do final permutations
  131:    */
  132:   _ufc_dofinalperm_r (res, data);
  133: 
  134:   /*
  135:    * And convert back to 6 bit ASCII
  136:    */
  137:   _ufc_output_conversion_r (res[0], res[1], salt, data);
  138:   return data->crypt_3_buf;
  139: }
  140: weak_alias (__crypt_r, crypt_r)
  141: 
  142: char *
  143: crypt (key, salt)
  144:      const char *key;
  145:      const char *salt;
  146: {
  147: #ifdef _LIBC
  148:   /* Try to find out whether we have to use MD5 encryption replacement.  */
  149:   if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0)
  150:     return __md5_crypt (key, salt);
  151: 
  152:   /* Try to find out whether we have to use SHA256 encryption replacement.  */
  153:   if (strncmp (sha256_salt_prefix, salt, sizeof (sha256_salt_prefix) - 1) == 0)
  154:     return __sha256_crypt (key, salt);
  155: 
  156:   /* Try to find out whether we have to use SHA512 encryption replacement.  */
  157:   if (strncmp (sha512_salt_prefix, salt, sizeof (sha512_salt_prefix) - 1) == 0)
  158:     return __sha512_crypt (key, salt);
  159: #endif
  160: 
  161:   return __crypt_r (key, salt, &_ufc_foobar);
  162: }
  163: 
  164: 
  165: /*
  166:  * To make fcrypt users happy.
  167:  * They don't need to call init_des.
  168:  */
  169: #ifdef _LIBC
  170: weak_alias (crypt, fcrypt)
  171: #else
  172: char *
  173: __fcrypt (key, salt)
  174:      const char *key;
  175:      const char *salt;
  176: {
  177:   return crypt (key, salt);
  178: }
  179: #endif