Debian Codegraph @

test/ka-table-gen.py

raw
1 #! /usr/bin/python3
2 # Compute test cases for ka-* tests.
3 #
4 # Written by Zack Weinberg <zackw at panix.com> in 2019.
5 # To the extent possible under law, Zack Weinberg has waived all
6 # copyright and related or neighboring rights to this work.
7 #
8 # See https://creativecommons.org/publicdomain/zero/1.0/ for further
9 # details.
10
11 # This program generates ka-table.inc, which defines the set
12 # of tests performed by the ka-*.c tests. It is not run automatically
13 # during the build for two reasons: it's very slow, and it requires Python
14 # 3.6 or greater with Passlib <https://passlib.readthedocs.io/en/stable/>
15 # available.
16 #
17 # If you modify this program, make sure to update ka-table.inc,
18 # by running 'make regen-ka-table' (libcrypt.so must already have been
19 # built), and then check in the updates to that file in the same
20 # commit as your changes to this program. You will need to install
21 # Passlib itself, but not any other libraries.
22 #
23 # This program intentionally uses Passlib's slow pure-Python back
24 # ends, rather than accelerated C modules that tend to be, at their
25 # core, the same code libxcrypt uses itself, so that we really are
26 # testing libxcrypt against known answers generated with a different
27 # implementation.
28
29 import array
30 import ctypes
31 import multiprocessing
32 import os
33 import re
34 import sys
35
36 # force passlib to allow use of its built-in bcrypt implementation
37 os.environ["PASSLIB_BUILTIN_BCRYPT"] = "enabled"
38
39 import passlib.hash
40
41 # In order to tickle various bugs and limitations in older hashing
42 # methods precisely, we need to test several passphrases whose byte
43 # sequences are not valid Unicode text in any encoding. We therefore
44 # use exclusively byte strings in this array.
45 PHRASES = [
46 # All ASCII printable, various lengths. Most of these were taken
47 # from older known-answer tests for specific hashing methods.
48 b'',
49 b' ',
50 b'a',
51 b'ab',
52 b'abc',
53 b'U*U',
54 b'U*U*',
55 b'U*U*U',
56 b'.....',
57 b'dragon',
58 b'dRaGoN',
59 b'DrAgOn',
60 b'PAROLX',
61 b'U*U***U',
62 b'abcdefg',
63 b'01234567',
64 b'726 even',
65 b'zyxwvuts',
66 b'ab1234567',
67 b'alexander',
68 b'beautiful',
69 b'challenge',
70 b'chocolate',
71 b'cr1234567',
72 b'katherine',
73 b'stephanie',
74 b'sunflower',
75 b'basketball',
76 b'porsche911',
77 b'|_337T`/p3',
78 b'thunderbird',
79 b'Hello world!',
80 b'pleaseletmein',
81 b'a short string',
82 b'zxyDPWgydbQjgq',
83 b'photojournalism',
84 b'ecclesiastically',
85 b'congregationalism',
86 b'dihydrosphingosine',
87 b'semianthropological',
88 b'palaeogeographically',
89 b'electromyographically',
90 b'noninterchangeableness',
91 b'abcdefghijklmnopqrstuvwxyz',
92 b'electroencephalographically',
93 b'antidisestablishmentarianism',
94 b'cyclotrimethylenetrinitramine',
95 b'dichlorodiphenyltrichloroethane',
96 b'multiple words seperated by spaces',
97 b'supercalifragilisticexpialidocious',
98 b'we have a short salt string but not a short password',
99 b'multiple word$ $eperated by $pace$ and $pecial character$',
100 b'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
101 (b'1234567890123456789012345678901234567890'
102 b'1234567890123456789012345678901234567890'),
103 (b'a very much longer text to encrypt. This one even stretches over more'
104 b'than one line.'),
105
106 # ASCII printables with their high bits flipped - DES-based hashes collide.
107 # All of these have an exact counterpart above.
108 b'\xd0\xc1\xd2\xcf\xcc\xd8', # 'PAROLX'
109 b'\xd5\xaa\xd5\xaa\xaa\xaa\xd5\xaa', # 'U*U***U*'
110 b'\xe1\xec\xe5\xf8\xe1\xee\xe4\xe5\xf2', # 'alexander'
111 b'\xf3\xf4\xe5\xf0\xe8\xe1\xee\xe9\xe5', # 'stephanie'
112 # '*U*U*U*U*U*U*U*U*'
113 b'\xaa\xd5\xaa\xd5\xaa\xd5\xaa\xd5\xaa\xd5\xaa\xd5\xaa\xd5\xaa\xd5\xaa',
114
115 # A few UTF-8 strings and what they will collide with for
116 # DES-based hashes.
117 b'\xC3\xA9tude', b'C)tude', # UTF-8(NFC(étude))
118 b'Chl\xC3\xB6e', b'ChlC6e', # UTF-8(NFC(Chlöe))
119 # Eight letters, but 10 bytes: UTF-8(NFC(Ångström))
120 b'\xC3\x85ngstr\xC3\xB6m', b'C\x05ngstrC6m', b'C\x05ngstrC'
121
122 # descrypt truncates everything to 8 characters.
123 b'U*U***U*', b'U*U***U*ignored',
124 b'U*U*U*U*', b'U*U*U*U*ignored',
125 b'*U*U*U*U', b'*U*U*U*U*', b'*U*U*U*U*U*U*U*U', b'*U*U*U*U*U*U*U*U*',
126
127 # Patterns designed to tickle the bcrypt $2x$ sign-extension bug.
128 b'\xa3',
129 b'\xa3a',
130 b'\xd1\x91',
131 b'\xa3ab',
132 b'\xff\xff\xa3',
133 b'1\xa3345',
134 b'\xff\xa3345',
135 b'\xff\xa334\xff\xff\xff\xa3345',
136
137 (b'\x55\xaa\xff\x55\xaa\xff\x55\xaa\xff\x55\xaa\xff'
138 b'\x55\xaa\xff\x55\xaa\xff\x55\xaa\xff\x55\xaa\xff'
139 b'\x55\xaa\xff\x55\xaa\xff\x55\xaa\xff\x55\xaa\xff'
140 b'\x55\xaa\xff\x55\xaa\xff\x55\xaa\xff\x55\xaa\xff'
141 b'\x55\xaa\xff\x55\xaa\xff\x55\xaa\xff\x55\xaa\xff'
142 b'\x55\xaa\xff\x55\xaa\xff\x55\xaa\xff\x55\xaa\xff'),
143
144 (b'\xaa\x55\xaa\x55\xaa\x55\xaa\x55\xaa\x55\xaa\x55'
145 b'\xaa\x55\xaa\x55\xaa\x55\xaa\x55\xaa\x55\xaa\x55'
146 b'\xaa\x55\xaa\x55\xaa\x55\xaa\x55\xaa\x55\xaa\x55'
147 b'\xaa\x55\xaa\x55\xaa\x55\xaa\x55\xaa\x55\xaa\x55'
148 b'\xaa\x55\xaa\x55\xaa\x55\xaa\x55\xaa\x55\xaa\x55'
149 b'\xaa\x55\xaa\x55\xaa\x55\xaa\x55\xaa\x55\xaa\x55'),
150
151 # bcrypt truncates to 72 characters
152 (b'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
153 b'0123456789'),
154 (b'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
155 b'0123456789chars after 72 are ignored'),
156
157 (b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa'
158 b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa'
159 b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa'
160 b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa'
161 b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa'
162 b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa'),
163
164 (b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa'
165 b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa'
166 b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa'
167 b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa'
168 b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa'
169 b'\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa'
170 b'chars after 72 are ignored as usual'),
171
172 # bigcrypt truncates to 128 characters
173 # (first sentence of _Twenty Thousand Leagues Under The Sea_)
174 (b'THE YEAR 1866 was marked by a bizarre development, an unexplained and '
175 b'downright inexplicable phenomenon that surely no one has forgotten.'),
176
177 # first 8 characters of above (des)
178 b'THE YEAR',
179 # first 72 characters (bcrypt)
180 b'THE YEAR 1866 was marked by a bizarre development, an unexplained and do',
181 # first 128 characters (bigcrypt)
182 (b'THE YEAR 1866 was marked by a bizarre development, an unexplained and '
183 b'downright inexplicable phenomenon that surely no one has f')
184 ]
185
186 # passlib does not support all of the hashing methods we do, no longer
187 # supports generation of bare setting strings, and in some cases does
188 # not support all of the variants we need to generate. Therefore,
189 # there is a shim for each hashing method (variant). Shims must be
190 # named 'h_METHOD' where METHOD is the name for the method used by the
191 # INCLUDE_method macros.
192 #
193 # Each shim function takes at least the arguments phrase, rounds, and
194 # salt, in that order. Additional optional arguments are allowed. It
195 # should do 'yield (phrase, setting, expected)' at least once, where
196 # phrase is the phrase argument, setting is a setting string generated
197 # from rounds and salt, and expected is the hashed passphrase expected
198 # to be generated from that combination of phrase and setting.
199 #
200 # When implementing new shims, use of passlib's pure-Python "backends"
201 # is strongly preferred where possible, because the speed of this
202 # program does not matter, and the C backends tend to be based on some
203 # incarnation of the same code that libxcrypt uses itself, so it
204 # wouldn't be a proper interop test.
205
206 # straightforward passlib wrappers, sorted by age of algorithm
207 DES_CRYPT = passlib.hash.des_crypt
208 DES_CRYPT.set_backend("builtin")
209 def h_descrypt(phrase, rounds, salt):
210 expected = DES_CRYPT.using(
211 salt=salt, truncate_error=False
212 ).hash(phrase)
213 setting = expected[:2]
214 yield (phrase, setting, expected)
215
216 BIGCRYPT = passlib.hash.bigcrypt
217 # BIGCRYPT.set_backend("builtin") # currently p.h.bigcrypt always uses builtin
218 def h_bigcrypt(phrase, rounds, salt):
219 # p.h.bigcrypt doesn't truncate to 128 chars.
220 # The bigcrypt implementation in libxcrypt was reverse engineered
221 # from a closed-source original and it's possible that they could
222 # have gotten it wrong, but let's stick to what we have.
223 expected = BIGCRYPT.using(
224 salt=salt
225 ).hash(phrase[:128])
226 # bigcrypt has no prefix, so our crypt() looks at the length of
227 # the setting string to decide whether it should use bigcrypt or
228 # descrypt. For bigcrypt to be used, the setting must be too long
229 # to be a traditional DES hashed password.
230 setting = expected[:2] + ".............."
231 yield (phrase, setting, expected)
232
233 BSDI_CRYPT = passlib.hash.bsdi_crypt
234 BSDI_CRYPT.set_backend("builtin")
235 def h_bsdicrypt(phrase, rounds, salt):
236 expected = BSDI_CRYPT.using(
237 salt=salt, rounds=rounds
238 ).hash(phrase)
239 setting = expected[:9]
240 yield (phrase, setting, expected)
241
242 MD5_CRYPT = passlib.hash.md5_crypt
243 MD5_CRYPT.set_backend("builtin")
244 def h_md5crypt(phrase, rounds, salt):
245 expected = MD5_CRYPT.using(
246 salt=salt
247 ).hash(phrase)
248 setting = expected[:expected.rfind('$')]
249 yield (phrase, setting, expected)
250
251 BSD_NTHASH = passlib.hash.bsd_nthash
252 #BSD_NTHASH.set_backend("builtin") # has only the built-in backend
253 def h_nt(phrase, rounds, salt):
254 # passlib.hash.bsd_nthash attempts to decode byte strings as UTF-8, which
255 # is Not What We Want. Python's iso_8859_1 is an identity map from 00..FF
256 # to U+0000..U+00FF, which is correct for this application.
257 expected = BSD_NTHASH.hash(phrase.decode("iso_8859_1"))
258 # NTHash doesn't have a salt.
259 # Older versions of libxcrypt generated a fake salt which
260 # we should ensure is ignored.
261 yield (phrase, "$3$", expected)
262 yield (phrase, "$3$__not_used__0123456789abcdef", expected)
263
264 SHA1_CRYPT = passlib.hash.sha1_crypt
265 SHA1_CRYPT.set_backend("builtin")
266 def h_sha1crypt(phrase, rounds, salt):
267 expected = SHA1_CRYPT.using(
268 salt=salt, rounds=rounds
269 ).hash(phrase)
270 setting = expected[:expected.rfind('$')]
271 yield (phrase, setting, expected)
272
273 SHA256_CRYPT = passlib.hash.sha256_crypt
274 SHA256_CRYPT.set_backend("builtin")
275 def h_sha256crypt(phrase, rounds, salt):
276 expected = SHA256_CRYPT.using(
277 salt=salt, rounds=rounds
278 ).hash(phrase)
279 setting = expected[:expected.rfind('$')]
280 yield (phrase, setting, expected)
281
282 SHA512_CRYPT = passlib.hash.sha512_crypt
283 SHA512_CRYPT.set_backend("builtin")
284 def h_sha512crypt(phrase, rounds, salt):
285 expected = SHA512_CRYPT.using(
286 salt=salt, rounds=rounds
287 ).hash(phrase)
288 setting = expected[:expected.rfind('$')]
289 yield (phrase, setting, expected)
290
291 # these need to do more work by hand
292
293 # We need to test setting strings both with and without the suffix
294 # that triggers the off-by-one error in the original Sun hash parser
295 # (which must be preserved by all interoperable implementations).
296 # passlib.hash.sun_md5_crypt.using(..., bare_salt=True) does not
297 # actually work.
298 from passlib.handlers.sun_md5_crypt import raw_sun_md5_crypt
299 def h_sunmd5(phrase, rounds, salt):
300
301 # sunmd5 is extremely slow in this test, compared to all the other
302 # hashes, because we have to do extra tests of bug-compatibility,
303 # because its round count cannot be reduced below 4096, and
304 # because on approximately half of those rounds it feeds an
305 # additional 1.5k of text to MD5_Update. The only optimization
306 # that wouldn't break compatibility would be to plug in a faster
307 # MD5 core, but that's not worth the engineering effort since it
308 # would only benefit obsolete hashes. Instead, skip most of the
309 # test phrases for this hash. This cuts the wall-clock time for
310 # ka-sunmd5 (on a current-generation x86-64) from fifty to nine
311 # seconds, which we can live with. sunmd5 feeds the phrase
312 # verbatim to MD5_Update, only once, with no length limit, so we
313 # don't need a lot of careful testing of different phrases. We do
314 # still include at least a few of the non-ASCII test phrases, and
315 # one very long phrase.
316 if 6 <= len(phrase) <= 128:
317 return
318
319 if rounds == 0:
320 bare_setting = "$md5$" + salt
321 else:
322 bare_setting = "$md5,rounds={}${}".format(rounds, salt)
323
324 suff_setting = bare_setting + "$"
325 bare_cksum = raw_sun_md5_crypt(phrase, rounds, bare_setting.encode("ascii"))
326 suff_cksum = raw_sun_md5_crypt(phrase, rounds, suff_setting.encode("ascii"))
327
328 bare_cksum = bare_cksum.decode("ascii")
329 suff_cksum = suff_cksum.decode("ascii")
330
331 yield (phrase, bare_setting, bare_setting + "$" + bare_cksum)
332 yield (phrase, bare_setting + "$x", bare_setting + "$" + bare_cksum)
333 yield (phrase, suff_setting, suff_setting + "$" + suff_cksum)
334 yield (phrase, suff_setting + "$", suff_setting + "$" + suff_cksum)
335
336 # testing bcrypt $2b$ and $2y$ is easy, but ...
337 BCRYPT = passlib.hash.bcrypt
338 BCRYPT.set_backend("builtin")
339 def h_bcrypt(phrase, rounds, salt):
340 expected = BCRYPT.using(
341 salt=salt, rounds=rounds, ident="2b"
342 ).hash(phrase)
343 setting = expected[:-31]
344 yield (phrase, setting, expected)
345
346 def h_bcrypt_y(phrase, rounds, salt):
347 expected = BCRYPT.using(
348 salt=salt, rounds=rounds, ident="2y"
349 ).hash(phrase)
350 setting = expected[:-31]
351 yield (phrase, setting, expected)
352
353 # ...passlib doesn't implement the quirks of crypt_blowfish's $2a$ or
354 # $2x$, but we really must test them. It is theoretically possible to
355 # implement the $2x$ quirk by a transformation on the input
356 # passphrase, but it would be hard to get right, and the $2a$ quirk
357 # cannot be implemented this way. The path of least resistance is to
358 # compute the $2b$ hash and then look up its output in a table of
359 # substitutions for each quirk. The collision resistance of the $2b$
360 # hash should protect us from false hits in these tables. (Remember
361 # that the $2x$ quirk is a _bug_, preserved for backward compatibility's
362 # sake, that causes output collisions; duplicate entries on the
363 # right-hand side of the $2x$ substitution table are expected.)
364 bcrypt_a_substitutions = {
365 'HdhhdUXVgLADnbTYf12kvsasO1gS51C': '5jlqAXzFdq.3//pJFBa432Pepsclbdu',
366 'caGU5ROXj4M8Tgsx3s/D5BQIuhazIWa': '7N5c8AaH.dbqz7.2o.V2mRkUDV0TZnO',
367 '8jdeg8QqT4CX3ERA9vZPFZAkxZRpxJW': 'D8jTC5oJeIumVOhMVpz79BzoGVhCjrW',
368 '9f4sA9SRA0scUKcRyC5kce8dao2.GKe': 'E8Lpo1/qkGPTBDBxEsJjeEzh9nkZ9uW',
369 'MOaOTHB4gEm.rriBjXNwBNh.Oc4mKGG': 'ZQhQBRpiYJCaQFgyHlB.t/F01cqLCIu',
370 'Qjdj3GXX7D0sFE9jji6wxSTWIhqI3US': 'euRNRfAA6e0fjpTfQPPAMU1PCOf9IHq',
371 'PIeeyENZVZmrKLAq5lwBUU9fMRVfV2m': 'h87NWu/js59XXaIj1hDyHxnjw7MJ5K6',
372 'VmFQpoXeVuKTzkg2ZRsAf.8PZJZg142': 'vrukkCtLqHBLoBDsz6QoBtSwzI9Qxiq',
373 }
374 def h_bcrypt_a(phrase, rounds, salt):
375 base = BCRYPT.using(
376 salt=salt, rounds=rounds, ident="2b"
377 ).hash(phrase)
378 base_setting = base[4:-31]
379 base_output = base[-31:]
380 output = bcrypt_a_substitutions.get(base_output, base_output)
381
382 setting = "$2a$" + base_setting
383 expected = setting + output
384 yield (phrase, setting, expected)
385
386 bcrypt_x_substitutions = {
387 'xGPMyJSPyyeICKolPQ2gecm8rOgHwz.': '.sDifhVkUxvjPx6U4yeM2tC411Wuc.W',
388 'SRMKxjeMqVSDMhSLhOnvtEZ/p5KhUbq': '1Z0zKnHbUU3q/kk//Pknlv19a4/T8.K',
389 'PQInhDOdCKnXeUE.n/L.kQmTKM9ldK2': '25hhqa/GOJGmXui3avNI5MN8lOI2bCW',
390 '7UwHe/ywPmdp.nr.ZLQSxd8hqn7qURW': '2E0h7UFL/4fALemA5ApWrCWllQXSPTu',
391 'FZEYKXyyMgG13MK0uV8dwNotWf4Wm6e': '2M7Vc.sF98e8DDmnxFjRfAmrudbv6y.',
392 'ZHZAnvydiPNiYH2VjRNhEAD6BEiyaWS': '3kVpkKaj1q2TAXm.ptIi98Nj3zVV8A2',
393 'I7vjUzDOKf8XqcK8VSCm9b0bwoSm1Qm': '6He0iAS8JsdM.iB4OQ4fbsKMXPagLhy',
394 'tLCLEXAt3RUjOgs.yvfWSni4j1JX/JS': '7bLwFi3rlVcl.xfhc7LxjqwOExfxki2',
395 'zQPVIDk6wF8XmESji30KDHFabTlu0WK': '8gGm3RkYFflDX50UQs.tJ8InKNy.HGO',
396 'KBv1eBM2he2T/QheS8zPHMejn5fMNRe': '8jdeg8QqT4CX3ERA9vZPFZAkxZRpxJW',
397 'XEhidoDX1kz.RFnwWIzMJvtW2aP/k4e': '8jdeg8QqT4CX3ERA9vZPFZAkxZRpxJW',
398 'UIzecIiCguM2sPh1F7L9IS3zOtmg5Im': '9f4sA9SRA0scUKcRyC5kce8dao2.GKe',
399 'Xl2V4mQ7s0zX0b4XXH/b9UkRRCWpq3e': '9f4sA9SRA0scUKcRyC5kce8dao2.GKe',
400 'tHwehGUs3q0b/Ejn42MsoM4Yv/iA1rq': '9iflVP0Ezo/iaxO0XS74wFglLNeryTS',
401 'K2KXzhsMefB8v6hJJG3bOyKV.XRf6Qe': 'C3nvb4DotHdnRYgOPcdiK0C4q.DkIDO',
402 'EuEnx.TyCLYgkTV/uhWL5xJTHV7ZMjG': 'HdhhdUXVgLADnbTYf12kvsasO1gS51C',
403 'oaE0x.b2rUEITWgPdg.GEcU4ePHLh6m': 'IZEWKJgp.b.KG29zgOadgd2rUt5iV1e',
404 '3cFqlEl7Y0HWaVLHpyyCqG8dBNk1DSm': 'IvJ5WHgSbYKj7g9hhdVsAjyzcnVT/.m',
405 'gI4g/1M6K/Sz2bsgu9VDeEl6reszuXa': 'J6Y/kPTV/aHj7iJKuDfD5OPjVTvT2BK',
406 'rz1efvzeJjL4mQ813hrZNg3p1.ivOii': 'MOaOTHB4gEm.rriBjXNwBNh.Oc4mKGG',
407 'Tp1b9XCEV16BcrQ.0k4xf7V/OGPZLnK': 'N5E4WSTo/R5henexIN1o8xkGwe2V86W',
408 'CARhc7ugFdgoPjDb7LUG.yQF2lboK6e': 'NjlOVoE5aHHQGtU9zc25wu0VykHnD1G',
409 'nCdKcLO57oLlc6J6sNnGyfT9FrIawiW': 'PIeeyENZVZmrKLAq5lwBUU9fMRVfV2m',
410 'DQjlTXDA5PBQ97.qBJY/vsHPQhLJDMe': 'PMOS6ygjFMSbDo.iJJam/G63inGIOBO',
411 '1qOUgfpg30XDHLx/zrbWiMRcWyFhwye': 'QZ7A0p9q1Ag9Utfnfl/xif8NiDtVhO.',
412 'h0JFRyDXfP0duxAkVxWGr8nMDEDvPca': 'QiT.KUY9PXgIzL2aECMKb0EvVl0Pzw6',
413 'BvtRGGx3p8o0C5C36uS442Qqnrwofrq': 'Qjdj3GXX7D0sFE9jji6wxSTWIhqI3US',
414 'UTFLPGm29p.YVzcY6pqejGEql1x8Ccq': 'TYqa73Yp3leHe3D6.ysuJtNLwOma87C',
415 'YdPam5/ypFIyDUQMyCCEIwzVsTi0Sa6': 'TmFuGBy/Zgc6JVAr667oHeCvGQGyS1q',
416 'gbhoNOH4mWxoEhRrQNdeI.rpk9XeuZS': 'UPPO3QqmgMIXGHvbOLe2IkNzHLAToY2',
417 'ZkQGqjbMpqQ9oCsxNZjN8LQJaHFqPMC': 'VTMVcF7YBLV2/O6V1PNcQw0BD3hTN6a',
418 'RbKkfW2ph8bd8B5yul5E97DxgDw9cT.': 'VmFQpoXeVuKTzkg2ZRsAf.8PZJZg142',
419 'WI7ZNXFtzCd9mN1mWoNMQRHEmkDsZnm': 'VmFQpoXeVuKTzkg2ZRsAf.8PZJZg142',
420 '2WegkGS5Xr/qYNkfEi6JmnR16WVSwcW': 'Xv3TUB0NdnMpyn4cfg4g48oZxRSIrNC',
421 'LN/CEHXLfFeYdOOxbdxKu8ZqSIKgqAu': 'YdqUOXeMKw7X6zbqBXP6c1xqIKun7Oq',
422 'VAQY6kySmwStlNY.sut9Y87njVr0mm.': 'Ysbn1VpHCTzInfW/z/8Q3k676rxfmSW',
423 'qJn4AY9ch/WAR5JXeeJtVGeovjQrhd2': 'ZH9vItRapPbkFKo0iQqU4v71o0e19Mm',
424 '4QrucGf30zIbQA.sO0d1QrU63xBrEYq': 'bqJMLkbvnTFj0OYMu9tPnQXstRzX/e6',
425 'HD8RnTmGEavoR3LFVfdHvh3xA0QPka2': 'cYbtH8J2lfpMIiBKfF3pKpMno7JlLui',
426 '6WgD2zYQDPgxR2sXlUeEeGKknxt95W.': 'caGU5ROXj4M8Tgsx3s/D5BQIuhazIWa',
427 'rPSVExmrZ2WB1xntSbqZ/DRQRlKtVw.': 'caGU5ROXj4M8Tgsx3s/D5BQIuhazIWa',
428 'PYLCOpTKZmhFn1CoBM2XNbWgqMX4Jk2': 'cxMAJfIx3T.Fv3O0KjL9VdM/oSSUVRK',
429 'w8RVl3rh7sNazq544l0944qGq4GUFUq': 'fOj7giyJz5k22FHTKGVo8o1o5zGzPsq',
430 'KHsCqMFVxOAGJObHwEBR3JaEdKVu1.m': 'fRmxM11/x97bxCrhecMENdkPm7YpRbe',
431 '3wn02pxRJPnFwvlGt75DURDbt4g7om.': 'fY4v5x6.8txtKUKDP86z1xjlXG/GgZO',
432 'k9Hv17Gha84losGKAq61csCZokj5pyy': 'gLfxf5sydYesf658mrFYb51nLrn/4Sm',
433 'uTNb9MEHVGI7kd6UnQjYxgRNiKJM01S': 'h.z2vLHB/tYSU5fPXkrYB7TxLHGJnI6',
434 'heAts1y/8kcTTP0/vD3yeuMX1ihF8dO': 'j72N2Fi2j3pGalOZvTqtyH3bYGotuju',
435 'SqNATdQiNEckAKLsqgsKbAM5.hZoMCq': 'mjGosqV8OkKEcduYTNz5PKN2scswFya',
436 'k786rdsOdUP4cRi.dLa3dsYueMj5UnS': 'nQF1kDoMDjBBwXy2wwMni2gJLKqA0ta',
437 'G6PeIXKiqeNUPUbqFkMJvvI7G9hd51W': 'oBvt6zJCTP5OED1esTYUYPn31cWqwsa',
438 'TszY8.avBpwJ6xbNjwws3SKBbK6kj6S': 'odAvHZH9azlhi1x4pBLF25.hj08RMFi',
439 'z4QFggBRTVUeHRGL/CQxlAYHraYPcpa': 'ojiyBkc.4HZ2y5Yh0LxBbI6ZkLiRg0C',
440 'PPtdI0NcxZ4Txyv/Y5ORfcP1XFriKT2': 'pjce7u/YRnectNa8DXjsSGzRdyH2PSG',
441 'uIZ1Lgb.jHRDU/Z/LVXfpQCK72fTEHq': 'q5NMeQZ0UTyP/bILj02wdQ.Si5KHU1K',
442 '51cV.PJOQVwmiao4t4lXsb9Cc3Jnuem': 'rB3dV.fJGdSihNlP0vo5PemoaZRp6LS',
443 's6h1E6A2RzVn2KxXLQXsKosQeRo8bLa': 'sND7G4.cx6Dzn6TqbXfK99bElU0a7P.',
444 'A96emG/jBf0K1K6vCG.eZGdLkSridom': 'tlD3cmtHgs/TwWAvy5E3F.freZS1bau',
445 'hWYb0x3Q3zM0aBkB2G1arbzmWxRQS/i': 'whpbcVuyGrJbgveSSM3XQKa8G5alyRm',
446 'AqM0XavJxJXeVlJ3Te3umGJaPOCYmZi': 'xP2lldc1.10LvZDjJZXNBKLzWqnkbOa',
447 'UPBzTBMwJb5mKWflQ.5Rid4481RrxVy': 'xSD.pz8Zg3vt0Jiovghl5Dqrs8aw8ni',
448 'yM59Cq5iVZDB3u45gTNhRSnOgrY1tdG': 'yED5tIjzyeH90te88BUWvTrMFHsWgCi',
449 'k.qekGiJym3QgfeFCwNhPHg0Zk99KSa': 'yphVralDu2JlxYbCqwwGli/H6wBgBtC',
450 'iYbzuFNFwSfCgqTGNsUFtSDh8PJAqSe': 'zAUUWh4XGsBGYs6yyUJTSfEgzoLXO6G',
451 }
452 def h_bcrypt_x(phrase, rounds, salt):
453 base = BCRYPT.using(
454 salt=salt, rounds=rounds, ident="2b"
455 ).hash(phrase)
456 base_setting = base[4:-31]
457 base_output = base[-31:]
458 output = bcrypt_x_substitutions.get(base_output, base_output)
459
460 setting = "$2x$" + base_setting
461 expected = setting + output
462 yield (phrase, setting, expected)
463
464 # passlib includes an scrypt implementation, but its encoded password
465 # format is not the $7$ format we implement, so instead we use the
466 # stdlib's hashlib.scrypt (this is why 3.6+ is required) and encode
467 # the setting string by hand. This may produce strings encoding N/r/p
468 # combinations that don't normally occur in the wild, but that's OK.
469 # The algorithm implemented by hashlib.scrypt is standardized as
470 # RFC 7914, so it's not an issue where that implementation came from.
471 # Yes, the salt is properly passed to raw_scrypt as-is.
472 from hashlib import scrypt as raw_scrypt
473 from passlib.utils.binary import h64 as hash64
474 def h_scrypt(phrase, rounds, salt):
475 p = 1
476 r = 8
477 log2N = rounds + 7
478 N = 1 << log2N
479
480 bytesalt = salt.encode("ascii")
481 setting = (b"$7$" +
482 hash64.encode_int6(log2N) +
483 hash64.encode_int30(r) +
484 hash64.encode_int30(p) +
485 bytesalt)
486
487 binhash = raw_scrypt(phrase, salt=bytesalt, p=p, r=r, n=N, dklen=32)
488
489 yield (phrase, setting, setting + b'$' + hash64.encode_bytes(binhash))
490
491 #
492 # passlib does not support either yescrypt or gost-yescrypt. In fact,
493 # as far as I can tell, at the time of writing, there exists only one
494 # implementation of yescrypt and gost-yescrypt, by Solar Designer et al
495 # which is the code we use ourselves. However, a test for round-
496 # trippability and API consistency is still worthwhile, as is a test
497 # that the implementation's current behavior is compatible with its
498 # behavior some time ago. Therefore, we encode setting strings by
499 # hand, and ctypes is used to access crypt_ra in the just-built
500 # libcrypt.so. This will only work if the library was configured with
501 # --enable-hashes=yescrypt,gost-yescrypt,[others] and --enable-shared,
502 # which is OK, since it's not run during a normal build. Remove this
503 # once passlib supports these hashes.
504 #
505 # crypt_ra is used because it's thread-safe but doesn't require us to
506 # know how big struct crypt_data is. There is no good way to arrange
507 # for the data object to be deallocated. Oh well.
508 LIBCRYPT = ctypes.cdll.LoadLibrary(os.path.join(os.getcwd(), ".libs",
509 "libcrypt.so"))
510 _xcrypt_crypt_ra = LIBCRYPT.crypt_ra
511 _xcrypt_crypt_ra.argtypes = [ctypes.c_char_p, ctypes.c_char_p,
512 ctypes.POINTER(ctypes.c_void_p),
513 ctypes.POINTER(ctypes.c_int)]
514 _xcrypt_crypt_ra.restype = ctypes.c_char_p
515 _xcrypt_crypt_ra_data = ctypes.c_void_p(0)
516 _xcrypt_crypt_ra_datasize = ctypes.c_int(0)
517
518 def xcrypt_crypt(phrase, setting):
519 global _xcrypt_crypt_ra_data, _xcrypt_crypt_ra_datasize
520 if not isinstance(phrase, bytes): phrase = phrase.encode("utf-8")
521 if not isinstance(setting, bytes): setting = setting.encode("ascii")
522 rv = _xcrypt_crypt_ra(phrase, setting,
523 ctypes.byref(_xcrypt_crypt_ra_data),
524 ctypes.byref(_xcrypt_crypt_ra_datasize))
525 if not rv:
526 err = ctypes.get_errno()
527 raise OSError(err, os.strerror(err))
528 return bytes(rv)
529
530 def h_sm3crypt(phrase, rounds, salt):
531 setting = "$sm3$rounds={r}${s}".format(r=rounds, s=salt)
532 yield (phrase, setting, xcrypt_crypt(phrase, setting))
533
534 def yescrypt_gensalt(ident, rounds, salt):
535 if rounds == 1:
536 params = "j75"
537 elif rounds == 2:
538 params = "j85"
539 else:
540 raise RuntimeError("don't know how to encode rounds={}"
541 .format(rounds))
542
543 return "${}${}${}".format(ident, params, salt)
544
545 def h_yescrypt(phrase, rounds, salt):
546 setting = yescrypt_gensalt("y", rounds, salt)
547 yield (phrase, setting, xcrypt_crypt(phrase, setting))
548
549 def h_gost_yescrypt(phrase, rounds, salt):
550 setting = yescrypt_gensalt("gy", rounds, salt)
551 yield (phrase, setting, xcrypt_crypt(phrase, setting))
552
553 def h_sm3_yescrypt(phrase, rounds, salt):
554 setting = yescrypt_gensalt("sm3y", rounds, salt)
555 yield (phrase, setting, xcrypt_crypt(phrase, setting))
556
557
558 # Each method should contribute a group of parameters to the array
559 # below. Each block has the form
560 #
561 # ('method', [
562 # (rounds, salt),
563 # (rounds, salt),
564 # ...
565 # ])
566 #
567 # where 'method' is the method name used in the INCLUDE_ macros,
568 # rounds is a number and salt is a salt string. The appropriate
569 # h_method function will be called with arguments (phrase, *params)
570 # where params is one of the tuples from its block, so it is OK to add
571 # extra arguments after the salt if necessary.
572 #
573 # If the method has a tunable rounds parameter, its array of
574 # (rounds, salt) pairs should have two salts * at least two values of
575 # the rounds parameter. If it does not, it should have two salts and
576 # use 0 for the rounds parameter.
577 #
578 # The point of this test is not to exercise brute force resistance,
579 # so keep cost parameters low.
580 #
581 # Methods should be in alphabetical order by their INCLUDE_macro name.
582
583 SETTINGS = [
584 ('bcrypt', [
585 (5, 'CCCCCCCCCCCCCCCCCCCCC.'),
586 (5, 'abcdefghijklmnopqrstuu'),
587 (4, 'CCCCCCCCCCCCCCCCCCCCC.'),
588 (4, 'abcdefghijklmnopqrstuu'),
589 ]),
590
591 ('bcrypt_y', [
592 (5, 'CCCCCCCCCCCCCCCCCCCCC.'),
593 (5, 'abcdefghijklmnopqrstuu'),
594 (4, 'CCCCCCCCCCCCCCCCCCCCC.'),
595 (4, 'abcdefghijklmnopqrstuu'),
596 ]),
597
598 ('bcrypt_a', [
599 (5, 'CCCCCCCCCCCCCCCCCCCCC.'),
600 (5, 'abcdefghijklmnopqrstuu'),
601 (4, 'CCCCCCCCCCCCCCCCCCCCC.'),
602 (4, 'abcdefghijklmnopqrstuu'),
603 ]),
604
605 ('bcrypt_x', [
606 (5, 'CCCCCCCCCCCCCCCCCCCCC.'),
607 (5, 'abcdefghijklmnopqrstuu'),
608 (4, 'CCCCCCCCCCCCCCCCCCCCC.'),
609 (4, 'abcdefghijklmnopqrstuu'),
610 ]),
611
612 ('bigcrypt', [
613 (0, 'CC'),
614 (0, 'ab'),
615 ]),
616
617 # The bsdicrypt round count is required to be odd.
618 ('bsdicrypt', [
619 (1, 'CCCC'),
620 (1, 'abcd'),
621 (13, 'CCCC'),
622 (13, 'abcd'),
623 ]),
624
625 ('descrypt', [
626 (0, 'CC'),
627 (0, 'ab'),
628 ]),
629
630 ('gost_yescrypt', [
631 (1, '.......'),
632 (1, 'LdJMENpBABJJ3hIHjB1Bi.'),
633 (2, '.......'),
634 (2, 'LdJMENpBABJJ3hIHjB1Bi.'),
635 ]),
636
637 ('md5crypt', [
638 (0, 'CCCCCCCC'),
639 (0, 'abcdefgh'),
640 ]),
641
642 ('nt', [
643 (0, ''),
644 ]),
645
646 ('scrypt', [
647 (1, 'SodiumChloride'),
648 (1, 'unUNunUNunUNun'),
649 (2, 'SodiumChloride'),
650 (2, 'unUNunUNunUNun'),
651 ]),
652
653 ('sha1crypt', [
654 (12, 'GGXpNqoJvglVTkGU'),
655 (12, 'xSZGpk6Bp4SA3.cR'),
656 (456, 'GGXpNqoJvglVTkGU'),
657 (456, 'xSZGpk6Bp4SA3.cR'),
658 ]),
659
660 ('sha256crypt', [
661 (1000, 'saltstring'),
662 (1000, 'short'),
663 (5000, 'saltstring'),
664 (5000, 'short'),
665 ]),
666
667 ('sha512crypt', [
668 (1000, 'saltstring'),
669 (1000, 'short'),
670 (5000, 'saltstring'),
671 (5000, 'short'),
672 ]),
673
674 ('sm3crypt', [
675 (1000, 'saltstring'),
676 (1000, 'short'),
677 (5000, 'saltstring'),
678 (5000, 'short'),
679 ]),
680
681 ('sm3_yescrypt', [
682 (1, '.......'),
683 (1, 'LdJMENpBABJJ3hIHjB1Bi.'),
684 (2, '.......'),
685 (2, 'LdJMENpBABJJ3hIHjB1Bi.'),
686 ]),
687
688 ('sunmd5', [
689 (0, '9ZLwtuTO'),
690 (0, '1xMeE.at'),
691 (12, '9ZLwtuTO'),
692 (12, '1xMeE.at'),
693 ]),
694
695 ('yescrypt', [
696 (1, '.......'),
697 (1, 'LdJMENpBABJJ3hIHjB1Bi.'),
698 (2, '.......'),
699 (2, 'LdJMENpBABJJ3hIHjB1Bi.'),
700 ]),
701 ]
702
703 # Normally, we expect that (1) for fixed salt, no two phrases hash to
704 # the same string; (2) for fixed phrase, no two settings produce the
705 # same string. The known exceptions are all due to limitations and/or
706 # bugs in the hashing method. Check the table produced by this
707 # program to ensure that all of the collisions in the ->expected
708 # strings are due to one of the known exceptions. test-crypt-kat.c
709 # itself doesn't need to do this test; as long as all of the hashes
710 # produced by the just-built crypt() match the appropriate ->expected
711 # string, no new collisions can have been introduced.
712
713 def strneq_7bit (p1, p2, limit):
714 n1 = len(p1)
715 n2 = len(p2)
716 for i in range(limit):
717 if i == n1 and i == n2:
718 # strings are the same length, within the limit, and no
719 # mismatched characters were found
720 return True
721 if i == n1 or i == n2:
722 # one string is longer than the other, within the limit
723 return False
724 if (p1[i] & 0x7F) != (p2[i] & 0x7F):
725 # characters not equal, after masking the 8th bit
726 return False
727 # reached the limit, no mismatches found
728 return True
729
730 # The bug in bcrypt mode "x" (preserved from the original
731 # implementation of bcrypt) is, at its root, that the code below
732 # sign- rather than zero-extends *p before or-ing it into 'tmp'.
733 # When *p has its 8th bit set, it is therefore or-ed in as
734 # 0xFF_FF_FF_xx rather than 0x00_00_00_xx, and clobbers the other
735 # three bytes in 'tmp'. Depending on its position within the input,
736 # this can erase up to three other characters of the passphrase.
737 # The exact set of strings involved in any one group of collisions is
738 # difficult to describe in words and may depend on the endianness of
739 # the CPU. The test cases in this file have only been verified on
740 # a little-endian CPU.
741 BF_KEY_LEN = 18
742
743 def buggy_expand_BF_key(phrase):
744 p = 0
745 lp = len(phrase)
746 expanded = [0]*BF_KEY_LEN
747 if lp > 0:
748 for i in range(BF_KEY_LEN):
749 tmp = 0
750 for j in range(4):
751 if p == lp:
752 c = 0
753 else:
754 c = phrase[p]
755 stmp = ((c & 0x7F) - (c & 0x80)) & 0xFFFFFFFF
756 tmp = ((tmp << 8) | stmp) & 0xFFFFFFFF
757 p += 1
758 if p == lp + 1:
759 p = 0
760 expanded[i] = tmp
761 return expanded
762
763 def sign_extension_collision_p(p1, p2):
764 return buggy_expand_BF_key(p1) == buggy_expand_BF_key(p2)
765
766 def equivalent_sunmd5_settings_p(s1, s2):
767 if s1[:4] != "$md5": return False
768 if s2[:4] != "$md5": return False
769
770 l1 = len(s1)
771 l2 = len(s2)
772 if l1 < l2:
773 ll = l1
774 lh = l2
775 sl = s1
776 sh = s2
777 else:
778 ll = l2
779 lh = l1
780 sl = s2
781 sh = s1
782 if sl[:ll] != sh[:ll]:
783 return False
784
785 # The two cases where sunmd5 settings are equivalent:
786 # $md5...$ and $md5...$$
787 # $md5... and $md5...$x
788 if sl[ll-1] == '$':
789 if ll+1 != lh or sh[ll] != '$':
790 return False
791 else:
792 if ll+2 != lh or sh[ll] != '$' or sh[ll+1] != 'x':
793 return False
794 return True
795
796 def collision_expected(p1, p2, s1, s2):
797 if not isinstance(p1, bytes): p1 = p1.encode("iso_8859_1")
798 if not isinstance(p2, bytes): p2 = p2.encode("iso_8859_1")
799 if isinstance(s1, bytes): s1 = s1.decode("ascii")
800 if isinstance(s2, bytes): s2 = s2.decode("ascii")
801 # Under no circumstances should two hashes with different settings
802 # collide, except...
803 if s1 != s2:
804 # a descrypt hash can collide with a bigcrypt hash when the phrase
805 # input to bigcrypt was fewer than 8 characters long
806 if ( s1[0] != '$' and s1[0] != '_'
807 and s2[0] != '$' and s2[0] != '_'
808 and ( (len(s1) == 2 and len(s2) > 2 and len(p2) <= 8)
809 or (len(s2) == 2 and len(s1) > 2 and len(p1) <= 8))):
810 return strneq_7bit(p1, p2, 8)
811
812 # all settings for NTHASH are equivalent
813 if s1[:3] == '$3$' and s2[:3] == '$3$':
814 return p1 == p2
815
816 # sunmd5 has pairs of equivalent settings
817 if equivalent_sunmd5_settings_p (s1, s2):
818 return p1 == p2
819
820 return False
821
822 if s1[:2] == '$2':
823 # bcrypt truncates passphrases to 72 characters
824 if p1[:72] == p2[:72]:
825 return True
826 # preserved bcrypt $2x bug?
827 if s1[:3] == '$2x' and sign_extension_collision_p(p1, p2):
828 return True
829 return False
830
831 if s1[0] != '$' and s1[0] != '_':
832 if len(s1) == 2:
833 # descrypt truncates passphrases to 8 characters and strips the
834 # 8th bit
835 return strneq_7bit(p1, p2, 8)
836 else:
837 # bigcrypt truncates passphrases to 128 characters and strips the
838 # 8th bit
839 return strneq_7bit(p1, p2, 128)
840
841 if s1[0] == '_':
842 # bsdicrypt does not truncate but does still strip the 8th bit
843 return strneq_7bit(p1, p2, max(len(p1), len(p2)))
844
845 return False
846
847 def report_unexpected_collision(p1, p2, s1, s2, expected):
848 sys.stderr.write("UNEXPECTED HASH COLLISION:\n"
849 " hash = {}\n"
850 " p1 = {!r}\n"
851 " p2 = {!r}\n"
852 " s1 = {!r}\n"
853 " s2 = {!r}\n"
854 "\n".format(expected, p1, p2, s1, s2))
855
856 # Master control.
857 #
858 # To reduce the painful slowness of this program _somewhat_,
859 # we use a multiprocessing pool to compute all of the hashes.
860
861 def generate_phrase_setting_combs():
862 for macro_name, settings in SETTINGS:
863 for phrase in PHRASES:
864 for setting in settings:
865 yield (macro_name, phrase, setting)
866
867 def worker_compute_one(args):
868 method, phrase, setting = args
869
870 import __main__
871 sfunc = getattr(__main__, 'h_' + method)
872 return [(method, case) for case in sfunc(phrase, *setting)]
873
874 # Python specifies that an \x escape in a string literal consumes
875 # exactly two subsequent hexadecimal digits. C, on the other hand,
876 # specifies that \x in a string literal consumes *any number of*
877 # hexadecimal digits, and if the hexadecimal number is larger than the
878 # range representable by 'unsigned char' the result is
879 # implementation-defined. For instance, "\x303" == "03" in Python,
880 # but in C the string on the left could be anything. The simplest way
881 # to deal with this is to escape the string Python's way and then
882 # replace sequences like '\x303' with '\x30""3'.
883 c_hex_escape_fixup_re_ = re.compile(
884 r"(\\x[0-9a-fA-F]{2})([0-9a-fA-F])")
885
886 def c_hex_escape(s):
887 if isinstance(s, bytes):
888 s = s.decode("iso_8859_1")
889 s = s.encode("unicode_escape").decode("ascii")
890
891 return c_hex_escape_fixup_re_.sub(r'\1""\2', s)
892
893 def format_case(phrase, setting, expected):
894 return (' {{ "{}", "{}", "{}" }},\n'
895 .format(c_hex_escape(setting),
896 c_hex_escape(expected),
897 c_hex_escape(phrase)))
898
899 def main():
900 # FIXME: This only detects collisions that actually happen, not
901 # collisions that ought to have happened but didn't. (Detecting
902 # collisions that ought to have happened, but didn't, would be
903 # unavoidably quadratic in the total number of test cases, so I'm
904 # not sure it's worth it.)
905 items = []
906 collisions = {}
907 collision_error = False
908 with multiprocessing.Pool() as pool:
909 for group in pool.imap(worker_compute_one,
910 generate_phrase_setting_combs(),
911 chunksize=100):
912 for method, (phrase, setting, expected) in group:
913 if expected in collisions:
914 p1, s1 = collisions[expected]
915 if not collision_expected(p1, phrase, s1, setting):
916 report_unexpected_collision(p1, phrase, s1, setting,
917 expected)
918 collision_error = True
919 else:
920 collisions[expected] = (phrase, setting)
921 items.append((method, format_case(phrase, setting, expected)))
922
923 if collision_error:
924 sys.exit(1)
925
926 sys.stdout.write(
927 "/* Known-answer tests for passphrase hashes. -*- mode: c -*-\n"
928 " Automatically generated by ka-table-gen.py.\n"
929 " Do not edit this file by hand. */\n\n")
930
931 prev_method = None
932 for method, case in items:
933 if method != prev_method:
934 if prev_method is not None:
935 sys.stdout.write("#endif // {}\n\n".format(prev_method))
936 sys.stdout.write("#if INCLUDE_{} && defined TEST_{}\n"
937 .format(method, method))
938 prev_method = method
939 sys.stdout.write(case)
940
941 if prev_method is not None:
942 sys.stdout.write("#endif // {}\n".format(prev_method))
943
944 if __name__ == '__main__':
945 main()