Debian Codegraph @

lib/crypt-bcrypt.c

raw
1 /*
2 * The crypt_blowfish homepage is:
3 *
4 * http://www.openwall.com/crypt/
5 *
6 * This code comes from John the Ripper password cracker, with reentrant
7 * and crypt(3) interfaces added, but optimizations specific to password
8 * cracking removed.
9 *
10 * Written by Solar Designer <solar at openwall.com> in 1998-2014.
11 * No copyright is claimed, and the software is hereby placed in the public
12 * domain. In case this attempt to disclaim copyright and place the software
13 * in the public domain is deemed null and void, then the software is
14 * Copyright (c) 1998-2014 Solar Designer and it is hereby released to the
15 * general public under the following terms:
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted.
19 *
20 * There's ABSOLUTELY NO WARRANTY, express or implied.
21 *
22 * It is my intent that you should be able to use this on your system,
23 * as part of a software package, or anywhere else to improve security,
24 * ensure compatibility, or for any other purpose. I would appreciate
25 * it if you give credit where it is due and keep your modifications in
26 * the public domain as well, but I don't require that in order to let
27 * you place this code and any modifications you make under a license
28 * of your choice.
29 *
30 * This implementation is fully compatible with OpenBSD's bcrypt.c for prefix
31 * "$2b$", originally by Niels Provos <provos at citi.umich.edu>, and it uses
32 * some of his ideas. The password hashing algorithm was designed by David
33 * Mazieres <dm at lcs.mit.edu>. For information on the level of
34 * compatibility for bcrypt hash prefixes other than "$2b$", please refer to
35 * the comments in BF_set_key() below and to the included crypt(3) man page.
36 *
37 * There's a paper on the algorithm that explains its design decisions:
38 *
39 * http://www.usenix.org/events/usenix99/provos.html
40 *
41 * Some of the tricks in BF_ROUND might be inspired by Eric Young's
42 * Blowfish library (I can't be sure if I would think of something if I
43 * hadn't seen his code).
44 */
45
46 #include "crypt-port.h"
47 #include "byteorder.h"
48
49 #include <errno.h>
50 #include <stdio.h>
51
52 #if INCLUDE_bcrypt || INCLUDE_bcrypt_a || INCLUDE_bcrypt_x || INCLUDE_bcrypt_y
53
54 #if defined(__i386__) || defined(__x86_64__) || \
55 defined(__alpha__) || defined(__hppa__)
56 #define BF_SCALE 1
57 #else
58 #define BF_SCALE 0
59 #endif
60
61 typedef uint32_t BF_word;
62 typedef int32_t BF_word_signed;
63
64 /* Set the int_to_cpu function according to the system's endianness */
65 #if XCRYPT_USE_BIGENDIAN
66 #define BF_WORD_TO_CPU(x) be32_to_cpu (x)
67 #else
68 #define BF_WORD_TO_CPU(x) le32_to_cpu (x)
69 #endif
70
71 /* Number of Blowfish rounds, this is also hardcoded into a few places */
72 #define BF_N 16
73
74 typedef BF_word BF_key[BF_N + 2];
75
76 typedef struct
77 {
78 BF_word S[4][0x100];
79 BF_key P;
80 } BF_ctx;
81
82 /*
83 * Magic IV for 64 Blowfish encryptions that we do at the end.
84 * The string is "OrpheanBeholderScryDoubt" on big-endian.
85 */
86 static const BF_word BF_magic_w[6] =
87 {
88 0x4F727068, 0x65616E42, 0x65686F6C,
89 0x64657253, 0x63727944, 0x6F756274
90 };
91
92 /*
93 * P-box and S-box tables initialized with digits of Pi.
94 */
95 static const BF_ctx BF_init_state =
96 {
97 {
98 {
99 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
100 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
101 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
102 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
103 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
104 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
105 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
106 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
107 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
108 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
109 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
110 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
111 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
112 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
113 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
114 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
115 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
116 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
117 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
118 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
119 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
120 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
121 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
122 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
123 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
124 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
125 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
126 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
127 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
128 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
129 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
130 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
131 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
132 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
133 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
134 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
135 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
136 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
137 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
138 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
139 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
140 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
141 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
142 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
143 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
144 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
145 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
146 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
147 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
148 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
149 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
150 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
151 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
152 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
153 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
154 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
155 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
156 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
157 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
158 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
159 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
160 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
161 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
162 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a
163 },
164 {
165 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
166 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
167 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
168 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
169 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
170 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
171 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
172 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
173 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
174 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
175 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
176 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
177 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
178 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
179 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
180 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
181 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
182 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
183 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
184 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
185 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
186 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
187 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
188 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
189 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
190 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
191 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
192 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
193 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
194 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
195 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
196 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
197 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
198 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
199 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
200 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
201 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
202 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
203 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
204 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
205 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
206 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
207 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
208 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
209 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
210 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
211 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
212 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
213 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
214 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
215 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
216 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
217 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
218 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
219 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
220 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
221 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
222 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
223 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
224 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
225 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
226 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
227 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
228 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7
229 },
230 {
231 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
232 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
233 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
234 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
235 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
236 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
237 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
238 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
239 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
240 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
241 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
242 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
243 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
244 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
245 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
246 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
247 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
248 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
249 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
250 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
251 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
252 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
253 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
254 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
255 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
256 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
257 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
258 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
259 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
260 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
261 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
262 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
263 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
264 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
265 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
266 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
267 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
268 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
269 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
270 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
271 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
272 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
273 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
274 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
275 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
276 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
277 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
278 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
279 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
280 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
281 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
282 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
283 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
284 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
285 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
286 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
287 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
288 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
289 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
290 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
291 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
292 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
293 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
294 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0
295 },
296 {
297 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
298 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
299 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
300 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
301 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
302 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
303 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
304 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
305 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
306 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
307 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
308 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
309 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
310 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
311 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
312 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
313 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
314 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
315 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
316 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
317 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
318 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
319 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
320 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
321 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
322 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
323 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
324 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
325 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
326 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
327 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
328 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
329 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
330 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
331 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
332 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
333 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
334 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
335 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
336 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
337 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
338 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
339 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
340 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
341 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
342 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
343 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
344 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
345 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
346 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
347 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
348 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
349 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
350 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
351 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
352 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
353 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
354 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
355 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
356 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
357 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
358 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
359 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
360 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
361 }
362 },
363 {
364 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
365 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
366 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
367 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
368 0x9216d5d9, 0x8979fb1b
369 }
370 };
371
372 static const unsigned char BF_itoa64[64 + 1] =
373 "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
374
375 static const unsigned char BF_atoi64[0x60] =
376 {
377 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 1,
378 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 64, 64, 64, 64, 64,
379 64, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
380 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 64, 64, 64, 64, 64,
381 64, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
382 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 64, 64, 64, 64, 64
383 };
384
385 #define BF_safe_atoi64(dst, src) \
386 { \
387 tmp = (unsigned char)(src); \
388 if ((unsigned int)(tmp -= 0x20) >= 0x60) return -1; \
389 tmp = BF_atoi64[tmp]; \
390 if (tmp > 63) return -1; \
391 (dst) = tmp; \
392 }
393
394 static int
395 BF_decode (BF_word * dst, const char *src, int size)
396 {
397 unsigned char *dptr = (unsigned char *) dst;
398 unsigned char *end = dptr + size;
399 const unsigned char *sptr = (const unsigned char *) src;
400 unsigned int tmp, c1, c2, c3, c4;
401
402 do
403 {
404 BF_safe_atoi64 (c1, *sptr++);
405 BF_safe_atoi64 (c2, *sptr++);
406 *dptr++ = (unsigned char)((c1 << 2) | ((c2 & 0x30) >> 4));
407 if (dptr >= end)
408 break;
409
410 BF_safe_atoi64 (c3, *sptr++);
411 *dptr++ = (unsigned char)(((c2 & 0x0F) << 4) | ((c3 & 0x3C) >> 2));
412 if (dptr >= end)
413 break;
414
415 BF_safe_atoi64 (c4, *sptr++);
416 *dptr++ = (unsigned char)(((c3 & 0x03) << 6) | c4);
417 }
418 while (dptr < end);
419
420 return 0;
421 }
422
423 static void
424 BF_encode (unsigned char *dst, const BF_word * src, int size)
425 {
426 const unsigned char *sptr = (const unsigned char *) src;
427 const unsigned char *end = sptr + size;
428 unsigned char *dptr = dst;
429 unsigned int c1, c2;
430
431 do
432 {
433 c1 = *sptr++;
434 *dptr++ = BF_itoa64[c1 >> 2];
435 c1 = (c1 & 0x03) << 4;
436 if (end - sptr <= 0)
437 {
438 *dptr++ = BF_itoa64[c1];
439 break;
440 }
441
442 c2 = *sptr++;
443 c1 |= c2 >> 4;
444 *dptr++ = BF_itoa64[c1];
445 c1 = (c2 & 0x0f) << 2;
446 if (end - sptr <= 0)
447 {
448 *dptr++ = BF_itoa64[c1];
449 break;
450 }
451
452 c2 = *sptr++;
453 c1 |= c2 >> 6;
454 *dptr++ = BF_itoa64[c1];
455 *dptr++ = BF_itoa64[c2 & 0x3f];
456 }
457 while (end - sptr > 0);
458 }
459
460 #if XCRYPT_USE_BIGENDIAN
461 static void
462 BF_swap (ARG_UNUSED(BF_word * x), ARG_UNUSED(int count))
463 {
464 }
465 #else
466 static void
467 BF_swap (BF_word * x, int count)
468 {
469 BF_word tmp;
470
471 do
472 {
473 tmp = *x;
474 tmp = (tmp << 16) | (tmp >> 16);
475 *x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF);
476 }
477 while (--count);
478 }
479 #endif
480
481 #if BF_SCALE
482 /* Architectures which can shift addresses left by 2 bits with no extra cost */
483 #define BF_ROUND(L, R, N) \
484 tmp1 = L & 0xFF; \
485 tmp2 = L >> 8; \
486 tmp2 &= 0xFF; \
487 tmp3 = L >> 16; \
488 tmp3 &= 0xFF; \
489 tmp4 = L >> 24; \
490 tmp1 = data->ctx.S[3][tmp1]; \
491 tmp2 = data->ctx.S[2][tmp2]; \
492 tmp3 = data->ctx.S[1][tmp3]; \
493 tmp3 += data->ctx.S[0][tmp4]; \
494 tmp3 ^= tmp2; \
495 R ^= data->ctx.P[N + 1]; \
496 tmp3 += tmp1; \
497 R ^= tmp3;
498 #else
499 /* Architectures with no complicated addressing modes supported */
500 #define BF_INDEX(S, i) \
501 BF_WORD_TO_CPU((((unsigned char *)S) + i))
502 #define BF_ROUND(L, R, N) \
503 tmp1 = L & 0xFF; \
504 tmp1 <<= 2; \
505 tmp2 = L >> 6; \
506 tmp2 &= 0x3FC; \
507 tmp3 = L >> 14; \
508 tmp3 &= 0x3FC; \
509 tmp4 = L >> 22; \
510 tmp4 &= 0x3FC; \
511 tmp1 = BF_INDEX(data->ctx.S[3], tmp1); \
512 tmp2 = BF_INDEX(data->ctx.S[2], tmp2); \
513 tmp3 = BF_INDEX(data->ctx.S[1], tmp3); \
514 tmp3 += BF_INDEX(data->ctx.S[0], tmp4); \
515 tmp3 ^= tmp2; \
516 R ^= data->ctx.P[N + 1]; \
517 tmp3 += tmp1; \
518 R ^= tmp3;
519 #endif
520
521 /*
522 * Encrypt one block, BF_N is hardcoded here.
523 */
524 #define BF_ENCRYPT \
525 L ^= data->ctx.P[0]; \
526 BF_ROUND(L, R, 0); \
527 BF_ROUND(R, L, 1); \
528 BF_ROUND(L, R, 2); \
529 BF_ROUND(R, L, 3); \
530 BF_ROUND(L, R, 4); \
531 BF_ROUND(R, L, 5); \
532 BF_ROUND(L, R, 6); \
533 BF_ROUND(R, L, 7); \
534 BF_ROUND(L, R, 8); \
535 BF_ROUND(R, L, 9); \
536 BF_ROUND(L, R, 10); \
537 BF_ROUND(R, L, 11); \
538 BF_ROUND(L, R, 12); \
539 BF_ROUND(R, L, 13); \
540 BF_ROUND(L, R, 14); \
541 BF_ROUND(R, L, 15); \
542 tmp4 = R; \
543 R = L; \
544 L = tmp4 ^ data->ctx.P[BF_N + 1];
545
546 #define BF_body() \
547 L = R = 0; \
548 ptr = data->ctx.P; \
549 do { \
550 ptr += 2; \
551 BF_ENCRYPT; \
552 *(ptr - 2) = L; \
553 *(ptr - 1) = R; \
554 } while (ptr < &data->ctx.P[BF_N + 2]); \
555 \
556 ptr = data->ctx.S[0]; \
557 do { \
558 ptr += 2; \
559 BF_ENCRYPT; \
560 *(ptr - 2) = L; \
561 *(ptr - 1) = R; \
562 } while (ptr < &data->ctx.S[3][0xFF]);
563
564 static void
565 BF_set_key (const char *key, BF_key expanded, BF_key initial,
566 unsigned char flags)
567 {
568 const char *ptr = key;
569 unsigned int bug, i, j;
570 BF_word safety, sign, diff, tmp[2];
571 BF_word_signed stmp;
572
573 /*
574 * There was a sign extension bug in older revisions of this function. While
575 * we would have liked to simply fix the bug and move on, we have to provide
576 * a backwards compatibility feature (essentially the bug) for some systems and
577 * a safety measure for some others. The latter is needed because for certain
578 * multiple inputs to the buggy algorithm there exist easily found inputs to
579 * the correct algorithm that produce the same hash. Thus, we optionally
580 * deviate from the correct algorithm just enough to avoid such collisions.
581 * While the bug itself affected the majority of passwords containing
582 * characters with the 8th bit set (although only a percentage of those in a
583 * collision-producing way), the anti-collision safety measure affects
584 * only a subset of passwords containing the '\xff' character (not even all of
585 * those passwords, just some of them). This character is not found in valid
586 * UTF-8 sequences and is rarely used in popular 8-bit character encodings.
587 * Thus, the safety measure is unlikely to cause much annoyance, and is a
588 * reasonable tradeoff to use when authenticating against existing hashes that
589 * are not reliably known to have been computed with the correct algorithm.
590 *
591 * We use an approach that tries to minimize side-channel leaks of password
592 * information - that is, we mostly use fixed-cost bitwise operations instead
593 * of branches or table lookups. (One conditional branch based on password
594 * length remains. It is not part of the bug aftermath, though, and is
595 * difficult and possibly unreasonable to avoid given the use of C strings by
596 * the caller, which results in similar timing leaks anyway.)
597 *
598 * For actual implementation, we set an array index in the variable "bug"
599 * (0 means no bug, 1 means sign extension bug emulation) and a flag in the
600 * variable "safety" (bit 16 is set when the safety measure is requested).
601 * Valid combinations of settings are:
602 *
603 * Prefix "$2a$": bug = 0, safety = 0x10000
604 * Prefix "$2b$": bug = 0, safety = 0
605 * Prefix "$2x$": bug = 1, safety = 0
606 * Prefix "$2y$": bug = 0, safety = 0
607 */
608 bug = (unsigned int) flags & 1;
609 safety = ((BF_word) flags & 2) << 15;
610
611 sign = diff = 0;
612
613 for (i = 0; i < BF_N + 2; i++)
614 {
615 tmp[0] = tmp[1] = 0;
616 for (j = 0; j < 4; j++)
617 {
618 tmp[0] <<= 8;
619 tmp[0] |= (unsigned char) *ptr; /* correct */
620 tmp[1] <<= 8;
621 stmp = (BF_word_signed) (signed char) *ptr; /* bug */
622 tmp[1] |= (BF_word) stmp; /* two steps avoid GCC 6 spurious warning */
623 /*
624 * Sign extension in the first char has no effect - nothing to overwrite yet,
625 * and those extra 24 bits will be fully shifted out of the 32-bit word. For
626 * chars 2, 3, 4 in each four-char block, we set bit 7 of "sign" if sign
627 * extension in tmp[1] occurs. Once this flag is set, it remains set.
628 */
629 if (j)
630 sign |= tmp[1] & 0x80;
631 if (!*ptr)
632 ptr = key;
633 else
634 ptr++;
635 }
636 diff |= tmp[0] ^ tmp[1]; /* Non-zero on any differences */
637
638 expanded[i] = tmp[bug];
639 initial[i] = BF_init_state.P[i] ^ tmp[bug];
640 }
641
642 /*
643 * At this point, "diff" is zero iff the correct and buggy algorithms produced
644 * exactly the same result. If so and if "sign" is non-zero, which indicates
645 * that there was a non-benign sign extension, this means that we have a
646 * collision between the correctly computed hash for this password and a set of
647 * passwords that could be supplied to the buggy algorithm. Our safety measure
648 * is meant to protect from such many-buggy to one-correct collisions, by
649 * deviating from the correct algorithm in such cases. Let's check for this.
650 */
651 diff |= diff >> 16; /* still zero iff exact match */
652 diff &= 0xffff; /* ditto */
653 diff += 0xffff; /* bit 16 set iff "diff" was non-zero (on non-match) */
654 sign <<= 9; /* move the non-benign sign extension flag to bit 16 */
655 sign &= ~diff & safety; /* action needed? */
656
657 /*
658 * If we have determined that we need to deviate from the correct algorithm,
659 * flip bit 16 in initial expanded key. (The choice of 16 is arbitrary, but
660 * let's stick to it now. It came out of the approach we used above, and it's
661 * not any worse than any other choice we could make.)
662 *
663 * It is crucial that we don't do the same to the expanded key used in the main
664 * Eksblowfish loop. By doing it to only one of these two, we deviate from a
665 * state that could be directly specified by a password to the buggy algorithm
666 * (and to the fully correct one as well, but that's a side-effect).
667 */
668 initial[0] ^= sign;
669 }
670
671 static const unsigned char flags_by_subtype[26] =
672 {
673 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
674 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 4, 0
675 };
676
677 /* prefix: $2z$00$ = 7 chars
678 (where z = a, b, x, or y, and 00 = a decimal number
679 from 00 to 31 inclusive)
680 salt: 22 chars */
681 #define BF_SETTING_LENGTH (7 + 22)
682
683 /* prefix: BF_SETTING_LENGTH
684 hash: 31 chars
685 terminator: 1 char */
686 #define BF_HASH_LENGTH (BF_SETTING_LENGTH + 31 + 1)
687
688 static_assert (BF_HASH_LENGTH <= CRYPT_OUTPUT_SIZE,
689 "CRYPT_OUTPUT_SIZE is too small for bcrypt");
690
691 /* BF_data holds all of the sensitive intermediate data used by
692 BF_crypt. */
693 struct BF_data
694 {
695 BF_ctx ctx;
696 BF_key expanded_key;
697 union
698 {
699 BF_word salt[4];
700 BF_word output[6];
701 } binary;
702 };
703
704 /* A BF_buffer holds a BF_data plus two extra output buffers used by
705 the self-test logic. One of them is slightly overlength so the
706 self-test can verify that BF_crypt emits exactly BF_HASH_LENGTH
707 bytes and no more. */
708 struct BF_buffer
709 {
710 struct BF_data data;
711 unsigned char re_output[BF_HASH_LENGTH];
712 unsigned char st_output[BF_HASH_LENGTH + 2];
713 };
714
715 static_assert (sizeof (struct BF_buffer) <= ALG_SPECIFIC_SIZE,
716 "ALG_SPECIFIC_SIZE is too small for bcrypt");
717
718
719 static bool
720 BF_crypt (const char *key, const char *setting, unsigned char *output,
721 struct BF_data *data, BF_word min)
722 {
723 BF_word L, R;
724 BF_word tmp1, tmp2, tmp3, tmp4;
725 BF_word *ptr;
726 BF_word count;
727 int i;
728
729 if (setting[0] != '$' ||
730 setting[1] != '2' ||
731 setting[2] < 'a' || setting[2] > 'z' ||
732 !flags_by_subtype[(unsigned int) (unsigned char) setting[2] - 'a'] ||
733 setting[3] != '$' ||
734 setting[4] < '0' || setting[4] > '3' ||
735 setting[5] < '0' || setting[5] > '9' ||
736 (setting[4] == '3' && setting[5] > '1') || setting[6] != '$')
737 {
738 errno = EINVAL;
739 return false;
740 }
741
742 count = (BF_word) 1 << ((setting[4] - '0') * 10 + (setting[5] - '0'));
743 if (count < min || BF_decode (data->binary.salt, &setting[7], 16))
744 {
745 errno = EINVAL;
746 return false;
747 }
748 BF_swap (data->binary.salt, 4);
749
750 BF_set_key (key, data->expanded_key, data->ctx.P,
751 flags_by_subtype[(unsigned int) (unsigned char) setting[2] -
752 'a']);
753
754 memcpy (data->ctx.S, BF_init_state.S, sizeof (data->ctx.S));
755
756 L = R = 0;
757 for (i = 0; i < BF_N + 2; i += 2)
758 {
759 L ^= data->binary.salt[i & 2];
760 R ^= data->binary.salt[(i & 2) + 1];
761 BF_ENCRYPT;
762 data->ctx.P[i] = L;
763 data->ctx.P[i + 1] = R;
764 }
765
766 ptr = data->ctx.S[0];
767 do
768 {
769 ptr += 4;
770 L ^= data->binary.salt[(BF_N + 2) & 3];
771 R ^= data->binary.salt[(BF_N + 3) & 3];
772 BF_ENCRYPT;
773 *(ptr - 4) = L;
774 *(ptr - 3) = R;
775
776 L ^= data->binary.salt[(BF_N + 4) & 3];
777 R ^= data->binary.salt[(BF_N + 5) & 3];
778 BF_ENCRYPT;
779 *(ptr - 2) = L;
780 *(ptr - 1) = R;
781 }
782 while (ptr < &data->ctx.S[3][0xFF]);
783
784 do
785 {
786 int done;
787
788 for (i = 0; i < BF_N + 2; i += 2)
789 {
790 data->ctx.P[i] ^= data->expanded_key[i];
791 data->ctx.P[i + 1] ^= data->expanded_key[i + 1];
792 }
793
794 done = 0;
795 do
796 {
797 BF_body ();
798 if (done)
799 break;
800 done = 1;
801
802 tmp1 = data->binary.salt[0];
803 tmp2 = data->binary.salt[1];
804 tmp3 = data->binary.salt[2];
805 tmp4 = data->binary.salt[3];
806 for (i = 0; i < BF_N; i += 4)
807 {
808 data->ctx.P[i] ^= tmp1;
809 data->ctx.P[i + 1] ^= tmp2;
810 data->ctx.P[i + 2] ^= tmp3;
811 data->ctx.P[i + 3] ^= tmp4;
812 }
813 data->ctx.P[16] ^= tmp1;
814 data->ctx.P[17] ^= tmp2;
815 }
816 while (1);
817 }
818 while (--count);
819
820 for (i = 0; i < 6; i += 2)
821 {
822 L = BF_magic_w[i];
823 R = BF_magic_w[i + 1];
824
825 count = 64;
826 do
827 {
828 BF_ENCRYPT;
829 }
830 while (--count);
831
832 data->binary.output[i] = L;
833 data->binary.output[i + 1] = R;
834 }
835
836 memcpy (output, setting, BF_SETTING_LENGTH - 1);
837 output[BF_SETTING_LENGTH - 1] =
838 BF_itoa64[(int)
839 BF_atoi64[(int) setting[BF_SETTING_LENGTH - 1] -
840 0x20] & 0x30];
841
842 /* This has to be bug-compatible with the original implementation, so
843 * only encode 23 of the 24 bytes. :-) */
844 BF_swap (data->binary.output, 6);
845 BF_encode (&output[BF_SETTING_LENGTH], data->binary.output, 23);
846 output[BF_HASH_LENGTH - 1] = '\0';
847
848 return true;
849 }
850
851 /*
852 * Please preserve the runtime self-test. It serves two purposes at once:
853 *
854 * 1. We really can't afford the risk of producing incompatible hashes e.g.
855 * when there's something like gcc bug 26587 again, whereas an application or
856 * library integrating this code might not also integrate our external tests or
857 * it might not run them after every build. Even if it does, the miscompile
858 * might only occur on the production build, but not on a testing build (such
859 * as because of different optimization settings). It is painful to recover
860 * from incorrectly-computed hashes - merely fixing whatever broke is not
861 * enough. Thus, a proactive measure like this self-test is needed.
862 *
863 * 2. We don't want to leave sensitive data from our actual password hash
864 * computation on the stack or in registers. Previous revisions of the code
865 * would do explicit cleanups, but simply running the self-test after hash
866 * computation is more reliable.
867 *
868 * The performance cost of this quick self-test is around 0.6% at the "$2a$08"
869 * setting.
870 */
871 static void
872 BF_full_crypt (const char *phrase, const char *setting,
873 uint8_t *output, size_t out_size,
874 void *scratch, size_t scr_size)
875 {
876 /* This shouldn't ever happen, but... */
877 if (out_size < BF_HASH_LENGTH || scr_size < sizeof (struct BF_buffer))
878 {
879 errno = ERANGE;
880 return;
881 }
882 struct BF_buffer *buffer = scratch;
883
884 /* Hash the supplied password */
885 if (!BF_crypt (phrase, setting, buffer->re_output, &buffer->data, 16))
886 return; /* errno has already been set */
887
888 /* Save and restore the current value of errno around the self-test. */
889 int save_errno = errno;
890
891 /* Do a quick self-test. It is important that we make both calls to
892 BF_crypt() from the same scope such that they likely use the same
893 stack locations, which makes the second call overwrite the first
894 call's sensitive data on the stack and makes it more likely that
895 any alignment related issues would be detected by the self-test. */
896
897 static const char test_key[] = "8b \xd0\xc1\xd2\xcf\xcc\xd8";
898 static const char test_setting_init[] = "$2a$00$abcdefghijklmnopqrstuu";
899 static const char *const test_hashes[2] =
900 {
901 "i1D709vfamulimlGcq0qq3UvuUasvEa\0\x55", /* 'a', 'b', 'y' */
902 "VUrPmXD6q/nVSSp7pNDhCR9071IfIRe\0\x55" /* 'x' */
903 };
904 const char *test_hash = test_hashes[0];
905 char test_setting[BF_SETTING_LENGTH];
906 unsigned int flags = flags_by_subtype[(unsigned int) (unsigned char)
907 setting[2] - 'a'];
908 bool ok;
909
910 memcpy (test_setting, test_setting_init, BF_SETTING_LENGTH);
911 test_hash = test_hashes[flags & 1];
912 test_setting[2] = setting[2];
913
914 memset (buffer->st_output, 0x55, sizeof buffer->st_output);
915
916 ok = (BF_crypt (test_key, test_setting, buffer->st_output, &buffer->data, 1)
917 && !memcmp (buffer->st_output, test_setting, BF_SETTING_LENGTH)
918 && !memcmp (buffer->st_output + BF_SETTING_LENGTH, test_hash,
919 sizeof buffer->st_output - (BF_SETTING_LENGTH + 1)));
920
921 /* Do a second self-test of the key-expansion "safety" logic. */
922 {
923 const char *k = "\xff\xa3" "34" "\xff\xff\xff\xa3" "345";
924 BF_key ae, ai, ye, yi;
925 BF_set_key (k, ae, ai, 2); /* $2a$ */
926 BF_set_key (k, ye, yi, 4); /* $2y$ */
927 ai[0] ^= 0x10000; /* undo the safety (for comparison) */
928 ok = ok && ai[0] == 0xdb9c59bc && ye[17] == 0x33343500 &&
929 !memcmp (ae, ye, sizeof (ae)) && !memcmp (ai, yi, sizeof (ai));
930 }
931
932 if (!ok)
933 {
934 /* Self-test failed; pretend we don't support this hash type. */
935 errno = EINVAL;
936 return;
937 }
938
939 /* Self-test succeeded; copy the true output into the true output
940 buffer and return. We already know there is enough space. */
941 memcpy (output, buffer->re_output, BF_HASH_LENGTH);
942 errno = save_errno;
943 }
944 #endif
945
946 #if INCLUDE_bcrypt || INCLUDE_bcrypt_a || INCLUDE_bcrypt_y
947 static void
948 BF_gensalt (char subtype, unsigned long count,
949 const uint8_t *rbytes, size_t nrbytes,
950 uint8_t *output, size_t o_size)
951 {
952 if (!count)
953 count = 5;
954 if (nrbytes < 16 ||
955 count < 4 || count > 31 ||
956 (subtype != 'a' && subtype != 'b' && subtype != 'y'))
957 {
958 errno = EINVAL;
959 return;
960 }
961 if (o_size < 7 + 22 + 1)
962 {
963 errno = ERANGE;
964 return;
965 }
966
967 BF_word aligned_rbytes[16 / sizeof(BF_word)];
968 memcpy(aligned_rbytes, rbytes, 16);
969
970 output[0] = '$';
971 output[1] = '2';
972 output[2] = (uint8_t)subtype;
973 output[3] = '$';
974 output[4] = (uint8_t)('0' + count / 10);
975 output[5] = (uint8_t)('0' + count % 10);
976 output[6] = '$';
977
978 BF_encode (&output[7], aligned_rbytes, 16);
979 output[7 + 22] = '\0';
980 }
981 #endif
982
983 #if INCLUDE_bcrypt
984 void
985 crypt_bcrypt_rn (const char *phrase, size_t ARG_UNUSED (phr_size),
986 const char *setting, size_t ARG_UNUSED (set_size),
987 uint8_t *output, size_t out_size,
988 void *scratch, size_t scr_size)
989 {
990 BF_full_crypt (phrase, setting, output, out_size, scratch, scr_size);
991 }
992
993 void
994 gensalt_bcrypt_rn (unsigned long count,
995 const uint8_t *rbytes, size_t nrbytes,
996 uint8_t *output, size_t o_size)
997 {
998 BF_gensalt ('b', count, rbytes, nrbytes, output, o_size);
999 }
1000 #endif
1001
1002 #if INCLUDE_bcrypt_a
1003 void
1004 crypt_bcrypt_a_rn (const char *phrase, size_t ARG_UNUSED (phr_size),
1005 const char *setting, size_t ARG_UNUSED (set_size),
1006 uint8_t *output, size_t out_size,
1007 void *scratch, size_t scr_size)
1008 {
1009 BF_full_crypt (phrase, setting, output, out_size, scratch, scr_size);
1010 }
1011
1012 void
1013 gensalt_bcrypt_a_rn (unsigned long count,
1014 const uint8_t *rbytes, size_t nrbytes,
1015 uint8_t *output, size_t o_size)
1016 {
1017 BF_gensalt ('a', count, rbytes, nrbytes, output, o_size);
1018 }
1019 #endif
1020
1021 #if INCLUDE_bcrypt_x
1022 void
1023 crypt_bcrypt_x_rn (const char *phrase, size_t ARG_UNUSED (phr_size),
1024 const char *setting, size_t ARG_UNUSED (set_size),
1025 uint8_t *output, size_t out_size,
1026 void *scratch, size_t scr_size)
1027 {
1028 BF_full_crypt (phrase, setting, output, out_size, scratch, scr_size);
1029 }
1030
1031 void
1032 gensalt_bcrypt_x_rn (ARG_UNUSED(unsigned long count),
1033 ARG_UNUSED(const uint8_t *rbytes),
1034 ARG_UNUSED(size_t nrbytes),
1035 ARG_UNUSED(uint8_t *output),
1036 ARG_UNUSED(size_t o_size))
1037 {
1038 /* The prefix '$2x$' MUST NOT be used for computing new hashes. */
1039 errno = EINVAL;
1040 return;
1041 }
1042 #endif
1043
1044 #if INCLUDE_bcrypt_y
1045 void
1046 crypt_bcrypt_y_rn (const char *phrase, size_t ARG_UNUSED (phr_size),
1047 const char *setting, size_t ARG_UNUSED (set_size),
1048 uint8_t *output, size_t out_size,
1049 void *scratch, size_t scr_size)
1050 {
1051 BF_full_crypt (phrase, setting, output, out_size, scratch, scr_size);
1052 }
1053
1054 void
1055 gensalt_bcrypt_y_rn (unsigned long count,
1056 const uint8_t *rbytes, size_t nrbytes,
1057 uint8_t *output, size_t o_size)
1058 {
1059 BF_gensalt ('y', count, rbytes, nrbytes, output, o_size);
1060 }
1061 #endif