1 /*
2 * UFC-crypt: ultra fast crypt(3) implementation
3 *
4 * Copyright (C) 1991-2023 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, see
18 * <https://www.gnu.org/licenses/>.
19 *
20 * crypt entry points
21 *
22 * @(#)crypt-entry.c 1.2 12/20/96
23 *
24 */
25
26 #ifdef DEBUG
27 #include <stdio.h>
28 #endif
29 #include <string.h>
30 #include <errno.h>
31 #include <fips-private.h>
32
33 #ifndef STATIC
34 #define STATIC static
35 #endif
36
37 #include "crypt-private.h"
38 #include <shlib-compat.h>
39
40 /* Prototypes for local functions. */
41 #ifndef __GNU_LIBRARY__
42 void _ufc_clearmem (char *start, int cnt);
43 #else
44 #define _ufc_clearmem(start, cnt) memset(start, 0, cnt)
45 #endif
46 extern char *__md5_crypt_r (const char *key, const char *salt, char *buffer,
47 int buflen);
48 extern char *__md5_crypt (const char *key, const char *salt);
49 extern char *__sha256_crypt_r (const char *key, const char *salt,
50 char *buffer, int buflen);
51 extern char *__sha256_crypt (const char *key, const char *salt);
52 extern char *__sha512_crypt_r (const char *key, const char *salt,
53 char *buffer, int buflen);
54 extern char *__sha512_crypt (const char *key, const char *salt);
55
56 /* Define our magic string to mark salt for MD5 encryption
57 replacement. This is meant to be the same as for other MD5 based
58 encryption implementations. */
59 static const char md5_salt_prefix[] = "$1$";
60
61 /* Magic string for SHA256 encryption. */
62 static const char sha256_salt_prefix[] = "$5$";
63
64 /* Magic string for SHA512 encryption. */
65 static const char sha512_salt_prefix[] = "$6$";
66
67 /* For use by the old, non-reentrant routines (crypt/encrypt/setkey) */
68 extern struct crypt_data _ufc_foobar;
69
70 /*
71 * UNIX crypt function
72 */
73
74 char *
75 __crypt_r (const char *key, const char *salt,
76 struct crypt_data * __restrict data)
77 {
78 ufc_long res[4];
79 char ktab[9];
80 ufc_long xx = 25; /* to cope with GCC long long compiler bugs */
81
82 #ifdef _LIBC
83 /* Try to find out whether we have to use MD5 encryption replacement. */
84 if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0)
85 {
86 /* FIPS rules out MD5 password encryption. */
87 if (fips_enabled_p ())
88 {
89 __set_errno (EPERM);
90 return NULL;
91 }
92 return __md5_crypt_r (key, salt, (char *) data,
93 sizeof (struct crypt_data));
94 }
95
96 /* Try to find out whether we have to use SHA256 encryption replacement. */
97 if (strncmp (sha256_salt_prefix, salt, sizeof (sha256_salt_prefix) - 1) == 0)
98 return __sha256_crypt_r (key, salt, (char *) data,
99 sizeof (struct crypt_data));
100
101 /* Try to find out whether we have to use SHA512 encryption replacement. */
102 if (strncmp (sha512_salt_prefix, salt, sizeof (sha512_salt_prefix) - 1) == 0)
103 return __sha512_crypt_r (key, salt, (char *) data,
104 sizeof (struct crypt_data));
105 #endif
106
107 /*
108 * Hack DES tables according to salt
109 */
110 if (!_ufc_setup_salt_r (salt, data))
111 {
112 __set_errno (EINVAL);
113 return NULL;
114 }
115
116 /* FIPS rules out DES password encryption. */
117 if (fips_enabled_p ())
118 {
119 __set_errno (EPERM);
120 return NULL;
121 }
122
123 /*
124 * Setup key schedule
125 */
126 _ufc_clearmem (ktab, (int) sizeof (ktab));
127 (void) strncpy (ktab, key, 8);
128 _ufc_mk_keytab_r (ktab, data);
129
130 /*
131 * Go for the 25 DES encryptions
132 */
133 _ufc_clearmem ((char*) res, (int) sizeof (res));
134 _ufc_doit_r (xx, data, &res[0]);
135
136 /*
137 * Do final permutations
138 */
139 _ufc_dofinalperm_r (res, data);
140
141 /*
142 * And convert back to 6 bit ASCII
143 */
144 _ufc_output_conversion_r (res[0], res[1], salt, data);
145
146 /*
147 * Erase key-dependent intermediate data. Data dependent only on
148 * the salt is not considered sensitive.
149 */
150 explicit_bzero (ktab, sizeof (ktab));
151 explicit_bzero (data->keysched, sizeof (data->keysched));
152 explicit_bzero (res, sizeof (res));
153
154 return data->crypt_3_buf;
155 }
156 weak_alias (__crypt_r, crypt_r)
157
158 char *
159 crypt (const char *key, const char *salt)
160 {
161 #ifdef _LIBC
162 /* Try to find out whether we have to use MD5 encryption replacement. */
163 if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0
164 /* Let __crypt_r deal with the error code if FIPS is enabled. */
165 && !fips_enabled_p ())
166 return __md5_crypt (key, salt);
167
168 /* Try to find out whether we have to use SHA256 encryption replacement. */
169 if (strncmp (sha256_salt_prefix, salt, sizeof (sha256_salt_prefix) - 1) == 0)
170 return __sha256_crypt (key, salt);
171
172 /* Try to find out whether we have to use SHA512 encryption replacement. */
173 if (strncmp (sha512_salt_prefix, salt, sizeof (sha512_salt_prefix) - 1) == 0)
174 return __sha512_crypt (key, salt);
175 #endif
176
177 return __crypt_r (key, salt, &_ufc_foobar);
178 }
179
180 #if SHLIB_COMPAT (libcrypt, GLIBC_2_0, GLIBC_2_28)
181 weak_alias (crypt, fcrypt)
182 compat_symbol (libcrypt, fcrypt, fcrypt, GLIBC_2_0);
183 #endif