(__md5_crypt_r): If buffers for key and salt are not aligned to
[kopensolaris-gnu/glibc.git] / crypt / md5-crypt.c
1 /* One way encryption based on MD5 sum.
2    Copyright (C) 1996, 1997, 1999, 2000 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Library General Public License as
8    published by the Free Software Foundation; either version 2 of the
9    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    Library General Public License for more details.
15
16    You should have received a copy of the GNU Library General Public
17    License along with the GNU C Library; see the file COPYING.LIB.  If not,
18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19    Boston, MA 02111-1307, USA.  */
20
21 #include <assert.h>
22 #include <errno.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/param.h>
26
27 #include "md5.h"
28
29
30 /* Define our magic string to mark salt for MD5 "encryption"
31    replacement.  This is meant to be the same as for other MD5 based
32    encryption implementations.  */
33 static const char md5_salt_prefix[] = "$1$";
34
35 /* Table with characters for base64 transformation.  */
36 static const char b64t[64] =
37 "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
38
39
40 /* Prototypes for local functions.  */
41 extern char *__md5_crypt_r (const char *key, const char *salt,
42                             char *buffer, int buflen);
43 extern char *__md5_crypt (const char *key, const char *salt);
44
45
46 /* This entry point is equivalent to the `crypt' function in Unix
47    libcs.  */
48 char *
49 __md5_crypt_r (key, salt, buffer, buflen)
50      const char *key;
51      const char *salt;
52      char *buffer;
53      int buflen;
54 {
55   unsigned char alt_result[16];
56   struct md5_ctx ctx;
57   struct md5_ctx alt_ctx;
58   size_t salt_len;
59   size_t key_len;
60   size_t cnt;
61   char *cp;
62
63   /* Find beginning of salt string.  The prefix should normally always
64      be present.  Just in case it is not.  */
65   if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0)
66     /* Skip salt prefix.  */
67     salt += sizeof (md5_salt_prefix) - 1;
68
69   salt_len = MIN (strcspn (salt, "$"), 8);
70   key_len = strlen (key);
71
72   if ((key - (char *) 0) % __alignof__ (md5_uint32) != 0)
73     {
74       char *tmp = (char *) alloca (key_len + __alignof__ (md5_uint32));
75       key = memcpy (tmp + __alignof__ (md5_uint32)
76                     + (tmp - (char *) 0) % __alignof__ (md5_uint32),
77                     key, key_len);
78       assert ((key - (char *) 0) % __alignof__ (md5_uint32) == 0);
79     }
80
81   if ((salt - (char *) 0) % __alignof__ (md5_uint32) != 0)
82     {
83       char *tmp = (char *) alloca (salt_len + __alignof__ (md5_uint32));
84       salt = memcpy (tmp + __alignof__ (md5_uint32)
85                      + (tmp - (char *) 0) % __alignof__ (md5_uint32),
86                      salt, salt_len);
87       assert ((salt - (char *) 0) % __alignof__ (md5_uint32) == 0);
88     }
89
90   /* Prepare for the real work.  */
91   __md5_init_ctx (&ctx);
92
93   /* Add the key string.  */
94   __md5_process_bytes (key, key_len, &ctx);
95
96   /* Because the SALT argument need not always have the salt prefix we
97      add it separately.  */
98   __md5_process_bytes (md5_salt_prefix, sizeof (md5_salt_prefix) - 1, &ctx);
99
100   /* The last part is the salt string.  This must be at most 8
101      characters and it ends at the first `$' character (for
102      compatibility which existing solutions).  */
103   __md5_process_bytes (salt, salt_len, &ctx);
104
105
106   /* Compute alternate MD5 sum with input KEY, SALT, and KEY.  The
107      final result will be added to the first context.  */
108   __md5_init_ctx (&alt_ctx);
109
110   /* Add key.  */
111   __md5_process_bytes (key, key_len, &alt_ctx);
112
113   /* Add salt.  */
114   __md5_process_bytes (salt, salt_len, &alt_ctx);
115
116   /* Add key again.  */
117   __md5_process_bytes (key, key_len, &alt_ctx);
118
119   /* Now get result of this (16 bytes) and add it to the other
120      context.  */
121   __md5_finish_ctx (&alt_ctx, alt_result);
122
123   /* Add for any character in the key one byte of the alternate sum.  */
124   for (cnt = key_len; cnt > 16; cnt -= 16)
125     __md5_process_bytes (alt_result, 16, &ctx);
126   __md5_process_bytes (alt_result, cnt, &ctx);
127
128   /* For the following code we need a NUL byte.  */
129   *alt_result = '\0';
130
131   /* The original implementation now does something weird: for every 1
132      bit in the key the first 0 is added to the buffer, for every 0
133      bit the first character of the key.  This does not seem to be
134      what was intended but we have to follow this to be compatible.  */
135   for (cnt = key_len; cnt > 0; cnt >>= 1)
136     __md5_process_bytes ((cnt & 1) != 0 ? (const char *) alt_result : key, 1,
137                          &ctx);
138
139   /* Create intermediate result.  */
140   __md5_finish_ctx (&ctx, alt_result);
141
142   /* Now comes another weirdness.  In fear of password crackers here
143      comes a quite long loop which just processes the output of the
144      previous round again.  We cannot ignore this here.  */
145   for (cnt = 0; cnt < 1000; ++cnt)
146     {
147       /* New context.  */
148       __md5_init_ctx (&ctx);
149
150       /* Add key or last result.  */
151       if ((cnt & 1) != 0)
152         __md5_process_bytes (key, key_len, &ctx);
153       else
154         __md5_process_bytes (alt_result, 16, &ctx);
155
156       /* Add salt for numbers not divisible by 3.  */
157       if (cnt % 3 != 0)
158         __md5_process_bytes (salt, salt_len, &ctx);
159
160       /* Add key for numbers not divisible by 7.  */
161       if (cnt % 7 != 0)
162         __md5_process_bytes (key, key_len, &ctx);
163
164       /* Add key or last result.  */
165       if ((cnt & 1) != 0)
166         __md5_process_bytes (alt_result, 16, &ctx);
167       else
168         __md5_process_bytes (key, key_len, &ctx);
169
170       /* Create intermediate result.  */
171       __md5_finish_ctx (&ctx, alt_result);
172     }
173
174   /* Now we can construct the result string.  It consists of three
175      parts.  */
176   cp = __stpncpy (buffer, md5_salt_prefix, MAX (0, buflen));
177   buflen -= sizeof (md5_salt_prefix);
178
179   cp = __stpncpy (cp, salt, MIN ((size_t) buflen, salt_len));
180   buflen -= MIN ((size_t) buflen, salt_len);
181
182   if (buflen > 0)
183     {
184       *cp++ = '$';
185       --buflen;
186     }
187
188 #define b64_from_24bit(B2, B1, B0, N)                                         \
189   do {                                                                        \
190     unsigned int w = ((B2) << 16) | ((B1) << 8) | (B0);                       \
191     int n = (N);                                                              \
192     while (n-- > 0 && buflen > 0)                                             \
193       {                                                                       \
194         *cp++ = b64t[w & 0x3f];                                               \
195         --buflen;                                                             \
196         w >>= 6;                                                              \
197       }                                                                       \
198   } while (0)
199
200
201   b64_from_24bit (alt_result[0], alt_result[6], alt_result[12], 4);
202   b64_from_24bit (alt_result[1], alt_result[7], alt_result[13], 4);
203   b64_from_24bit (alt_result[2], alt_result[8], alt_result[14], 4);
204   b64_from_24bit (alt_result[3], alt_result[9], alt_result[15], 4);
205   b64_from_24bit (alt_result[4], alt_result[10], alt_result[5], 4);
206   b64_from_24bit (0, 0, alt_result[11], 2);
207   if (buflen <= 0)
208     {
209       __set_errno (ERANGE);
210       buffer = NULL;
211     }
212   else
213     *cp = '\0';         /* Terminate the string.  */
214
215   /* Clear the buffer for the intermediate result so that people
216      attaching to processes or reading core dumps cannot get any
217      information.  */
218   memset (alt_result, '\0', sizeof (alt_result));
219
220   return buffer;
221 }
222
223
224 char *
225 __md5_crypt (const char *key, const char *salt)
226 {
227   /* We don't want to have an arbitrary limit in the size of the
228      password.  We can compute the size of the result in advance and
229      so we can prepare the buffer we pass to `md5_crypt_r'.  */
230   static char *buffer = NULL;
231   static int buflen = 0;
232   int needed = 3 + strlen (salt) + 1 + 26 + 1;
233
234   if (buflen < needed)
235     {
236       buflen = needed;
237       if ((buffer = realloc (buffer, buflen)) == NULL)
238         return NULL;
239     }
240
241   return __md5_crypt_r (key, salt, buffer, buflen);
242 }