1
2
3
4
5
6static const char str_rounds[] ALIGN1 = "rounds=%u$";
7
8
9#define SALT_LEN_MAX 16
10
11#define ROUNDS_DEFAULT 5000
12
13#define ROUNDS_MIN 1000
14
15#define ROUNDS_MAX 999999999
16
17static char *
18NOINLINE
19sha_crypt( char *key_data, char *salt_data)
20{
21#undef sha_end
22 void (*sha_begin)(void *ctx) FAST_FUNC;
23 void (*sha_hash)(void *ctx, const void *buffer, size_t len) FAST_FUNC;
24 unsigned (*sha_end)(void *ctx, void *resbuf) FAST_FUNC;
25 int _32or64;
26
27 char *result, *resptr;
28
29
30 struct {
31 unsigned char alt_result[64];
32 unsigned char temp_result[64];
33 union {
34 sha256_ctx_t x;
35 sha512_ctx_t y;
36 } ctx;
37 union {
38 sha256_ctx_t x;
39 sha512_ctx_t y;
40 } alt_ctx;
41 } L __attribute__((__aligned__(__alignof__(uint64_t))));
42#define alt_result (L.alt_result )
43#define temp_result (L.temp_result)
44#define ctx (L.ctx )
45#define alt_ctx (L.alt_ctx )
46 unsigned salt_len;
47 unsigned key_len;
48 unsigned cnt;
49 unsigned rounds;
50 char *cp;
51
52
53 cnt = strlen(salt_data) + 1 + 43 + 1;
54 _32or64 = 32;
55 if (salt_data[1] == '6') {
56 _32or64 *= 2;
57 cnt += 43;
58 }
59 result = resptr = xzalloc(cnt);
60 *resptr++ = '$';
61 *resptr++ = salt_data[1];
62 *resptr++ = '$';
63 rounds = ROUNDS_DEFAULT;
64 salt_data += 3;
65 if (strncmp(salt_data, str_rounds, 7) == 0) {
66
67 char *endp;
68 cnt = bb_strtou(salt_data + 7, &endp, 10);
69 if (*endp == '$') {
70 salt_data = endp + 1;
71 rounds = cnt;
72 if (rounds < ROUNDS_MIN)
73 rounds = ROUNDS_MIN;
74 if (rounds > ROUNDS_MAX)
75 rounds = ROUNDS_MAX;
76
77 resptr += sprintf(resptr, str_rounds, rounds);
78 }
79 }
80 salt_len = strchrnul(salt_data, '$') - salt_data;
81 if (salt_len > SALT_LEN_MAX)
82 salt_len = SALT_LEN_MAX;
83
84
85 salt_data = xstrndup(salt_data, salt_len);
86
87 strcpy(resptr, salt_data);
88 resptr += salt_len;
89 *resptr++ = '$';
90
91 key_len = strlen(key_data);
92 key_data = xstrdup(key_data);
93
94
95 sha_begin = (void*)sha256_begin;
96 sha_hash = (void*)sha256_hash;
97 sha_end = (void*)sha256_end;
98 if (_32or64 != 32) {
99 sha_begin = (void*)sha512_begin;
100 sha_hash = (void*)sha512_hash;
101 sha_end = (void*)sha512_end;
102 }
103
104
105 sha_begin(&ctx);
106 sha_hash(&ctx, key_data, key_len);
107 sha_hash(&ctx, salt_data, salt_len);
108
109
110
111 sha_begin(&alt_ctx);
112 sha_hash(&alt_ctx, key_data, key_len);
113 sha_hash(&alt_ctx, salt_data, salt_len);
114 sha_hash(&alt_ctx, key_data, key_len);
115 sha_end(&alt_ctx, alt_result);
116
117
118
119 for (cnt = key_len; cnt > _32or64; cnt -= _32or64)
120 sha_hash(&ctx, alt_result, _32or64);
121 sha_hash(&ctx, alt_result, cnt);
122
123
124
125 for (cnt = key_len; cnt != 0; cnt >>= 1)
126 if ((cnt & 1) != 0)
127 sha_hash(&ctx, alt_result, _32or64);
128 else
129 sha_hash(&ctx, key_data, key_len);
130
131
132 sha_end(&ctx, alt_result);
133
134
135
136 sha_begin(&alt_ctx);
137 for (cnt = 0; cnt < key_len; ++cnt)
138 sha_hash(&alt_ctx, key_data, key_len);
139 sha_end(&alt_ctx, temp_result);
140
141
142
143
144#define p_bytes key_data
145 cp = p_bytes;
146 for (cnt = key_len; cnt >= _32or64; cnt -= _32or64) {
147 cp = memcpy(cp, temp_result, _32or64);
148 cp += _32or64;
149 }
150 memcpy(cp, temp_result, cnt);
151
152
153
154 sha_begin(&alt_ctx);
155 for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt)
156 sha_hash(&alt_ctx, salt_data, salt_len);
157 sha_end(&alt_ctx, temp_result);
158
159
160
161
162#define s_bytes salt_data
163 cp = s_bytes;
164 for (cnt = salt_len; cnt >= _32or64; cnt -= _32or64) {
165 cp = memcpy(cp, temp_result, _32or64);
166 cp += _32or64;
167 }
168 memcpy(cp, temp_result, cnt);
169
170
171
172 for (cnt = 0; cnt < rounds; ++cnt) {
173 sha_begin(&ctx);
174
175
176 if ((cnt & 1) != 0)
177 sha_hash(&ctx, p_bytes, key_len);
178 else
179 sha_hash(&ctx, alt_result, _32or64);
180
181 if (cnt % 3 != 0)
182 sha_hash(&ctx, s_bytes, salt_len);
183
184 if (cnt % 7 != 0)
185 sha_hash(&ctx, p_bytes, key_len);
186
187 if ((cnt & 1) != 0)
188 sha_hash(&ctx, alt_result, _32or64);
189 else
190 sha_hash(&ctx, p_bytes, key_len);
191
192 sha_end(&ctx, alt_result);
193 }
194
195
196
197
198#define b64_from_24bit(B2, B1, B0, N) \
199do { \
200 unsigned w = ((B2) << 16) | ((B1) << 8) | (B0); \
201 resptr = to64(resptr, w, N); \
202} while (0)
203 if (_32or64 == 32) {
204 unsigned i = 0;
205 while (1) {
206 unsigned j = i + 10;
207 unsigned k = i + 20;
208 if (j >= 30) j -= 30;
209 if (k >= 30) k -= 30;
210 b64_from_24bit(alt_result[i], alt_result[j], alt_result[k], 4);
211 if (k == 29)
212 break;
213 i = k + 1;
214 }
215 b64_from_24bit(0, alt_result[31], alt_result[30], 3);
216
217
218
219
220
221
222
223
224
225
226
227
228
229 } else {
230 unsigned i = 0;
231 while (1) {
232 unsigned j = i + 21;
233 unsigned k = i + 42;
234 if (j >= 63) j -= 63;
235 if (k >= 63) k -= 63;
236 b64_from_24bit(alt_result[i], alt_result[j], alt_result[k], 4);
237 if (j == 20)
238 break;
239 i = j + 1;
240 }
241 b64_from_24bit(0, 0, alt_result[63], 2);
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266 }
267
268#undef b64_from_24bit
269
270
271
272
273 memset(&L, 0, sizeof(L));
274 memset(key_data, 0, key_len);
275 memset(salt_data, 0, salt_len);
276 free(key_data);
277 free(salt_data);
278#undef p_bytes
279#undef s_bytes
280
281 return result;
282#undef alt_result
283#undef temp_result
284#undef ctx
285#undef alt_ctx
286}
287