~mdw / catacomb / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
symm/blkc.h: Add a hook for cipher-specific initialization.
[catacomb] / symm / blkc.h
1 /* -*-c-*-
2 *
3 * Common definitions for block ciphers
4 *
5 * (c) 1999 Straylight/Edgeware
6 */
7
8 /*----- Licensing notice --------------------------------------------------*
9 *
10 * This file is part of Catacomb.
11 *
12 * Catacomb is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU Library General Public License as
14 * published by the Free Software Foundation; either version 2 of the
15 * License, or (at your option) any later version.
16 *
17 * Catacomb is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU Library General Public License for more details.
21 *
22 * You should have received a copy of the GNU Library General Public
23 * License along with Catacomb; if not, write to the Free
24 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
25 * MA 02111-1307, USA.
26 */
27
28 #ifndef CATACOMB_BLKC_H
29 #define CATACOMB_BLKC_H
30
31 #ifdef __cplusplus
32 extern "C" {
33 #endif
34
35 /*----- Header files ------------------------------------------------------*/
36
37 #include <assert.h>
38
39 #include <mLib/bits.h>
40
41 /*----- Theory of operation -----------------------------------------------*
42 *
43 * A block cipher has associated with it a triple, called PRE_CLASS, of the
44 * form `(TYPE, ENDIAN, BITS)', where TYPE is either `N' (representing an
45 * implemented bit size) or `X' (representing an unimplemented bit size,
46 * causing loops to be compiled rather than unrolled code), ENDIAN is `B'
47 * (big) or `L' (little), and BITS is the block size of the cipher in bits.
48 */
49
50 /*----- Data movement macros ----------------------------------------------*/
51
52 /*
53 * `The C preprocessor. You will never find a more wretched hive of bogus
54 * hackery. We must be cautious.'
55 */
56
57 /* --- General dispatch macros --- */
58
59 #define BLKC_DOGLUE(x, y) x ## y
60 #define BLKC_GLUE(x, y) BLKC_DOGLUE(x, y)
61 #define BLKC_APPLY(f, x) f x
62 #define BLKC_FIRST(x, y, z) x
63 #define BLKC_SECOND(x, y, z) y
64 #define BLKC_THIRD(x, y, z) z
65 #define BLKC_TYPE(PRE) BLKC_APPLY(BLKC_FIRST, PRE##_CLASS)
66 #define BLKC_ENDIAN(PRE) BLKC_APPLY(BLKC_SECOND, PRE##_CLASS)
67 #define BLKC_BITS(PRE) BLKC_APPLY(BLKC_THIRD, PRE##_CLASS)
68
69 #define BLKC_STORE_E(PRE) BLKC_GLUE(STORE32_, BLKC_ENDIAN(PRE))
70 #define BLKC_LOAD_E(PRE) BLKC_GLUE(LOAD32_, BLKC_ENDIAN(PRE))
71
72 #define BLKC_ID(x) (x)
73
74 /* --- Interface macros --- */
75
76 #define BLKC_STORE(PRE, b, w) \
77 BLKC_GLUE(BLKC_STORE_, BLKC_TYPE(PRE)) \
78 (PRE, b, w, BLKC_STORE_E(PRE), BLKC_BITS(PRE))
79
80 #define BLKC_XSTORE(PRE, b, w, wx) \
81 BLKC_GLUE(BLKC_XSTORE_, BLKC_TYPE(PRE)) \
82 (PRE, b, w, wx, BLKC_STORE_E(PRE), BLKC_BITS(PRE))
83
84 #define BLKC_LOAD(PRE, w, b) \
85 BLKC_GLUE(BLKC_LOAD_, BLKC_TYPE(PRE)) \
86 (PRE, w, b, BLKC_LOAD_E(PRE), BLKC_BITS(PRE))
87
88 #define BLKC_XLOAD(PRE, w, b) \
89 BLKC_GLUE(BLKC_XLOAD_, BLKC_TYPE(PRE)) \
90 (PRE, w, b, BLKC_LOAD_E(PRE), BLKC_BITS(PRE))
91
92 #define BLKC_MOVE(PRE, w, wx) \
93 BLKC_GLUE(BLKC_MOVE_, BLKC_TYPE(PRE)) \
94 (PRE, w, wx, BLKC_BITS(PRE))
95
96 #define BLKC_XMOVE(PRE, w, wx) \
97 BLKC_GLUE(BLKC_XMOVE_, BLKC_TYPE(PRE)) \
98 (PRE, w, wx, BLKC_BITS(PRE))
99
100 #define BLKC_BSTEP(PRE, w) BLKC_BADD(PRE, w, 1)
101 #define BLKC_LSTEP(PRE, w) BLKC_LADD(PRE, w, 1)
102 #define BLKC_STEP(PRE, w) BLKC_ADD(PRE, w, 1)
103
104 #define BLKC_BADD(PRE, w, n) \
105 BLKC_GLUE(BLKC_BADD_X_, BLKC_ENDIAN(PRE)) \
106 (PRE, w, n)
107 #define BLKC_LADD(PRE, w, n) \
108 BLKC_GLUE(BLKC_LADD_X_, BLKC_ENDIAN(PRE)) \
109 (PRE, w, n)
110 #define BLKC_ADD(PRE, w, n) \
111 BLKC_GLUE(BLKC_ADD_X_, BLKC_ENDIAN(PRE)) \
112 (PRE, BLKC_ID, w, n)
113
114 #define BLKC_ZERO(PRE, w) \
115 BLKC_GLUE(BLKC_ZERO_, BLKC_TYPE(PRE)) \
116 (PRE, w, BLKC_BITS(PRE))
117
118 #define BLKC_BSET(PRE, w, x) \
119 BLKC_GLUE(BLKC_BSET_X_, BLKC_ENDIAN(PRE)) \
120 (PRE, w, x)
121 #define BLKC_LSET(PRE, w, x) \
122 BLKC_GLUE(BLKC_LSET_X_, BLKC_ENDIAN(PRE)) \
123 (PRE, w, x)
124 #define BLKC_SET(PRE, w, x) \
125 BLKC_GLUE(BLKC_SET_X_, BLKC_ENDIAN(PRE)) \
126 (PRE, BLKC_ID, w, x)
127
128 #define BLKC_BWORD(PRE, x) BLKC_GLUE(BLKC_BWORD_, BLKC_ENDIAN(PRE))(x)
129 #define BLKC_LWORD(PRE, x) BLKC_GLUE(BLKC_LWORD_, BLKC_ENDIAN(PRE))(x)
130
131 #define BLKC_SHOW(PRE, tag, w) do { \
132 fputs(tag ": ", stdout); \
133 BLKC_SKEL_X(PRE, const BLKC_W(w);, \
134 { printf("%08x ", BLKC_BWORD(PRE, *_w)); _w++; }); \
135 fputc('\n', stdout); \
136 } while (0)
137
138 /* --- Utilities --- *
139 *
140 * These seem too hard to properly generalize, or I'd have put them in
141 * <mLib/bits.h>.
142 */
143
144 #ifdef HAVE_UINT64
145 # define BLKC_ADDC32(op, z_out, c_out, x, y) do { \
146 uint64 _t = (uint64)op(x) + (y); \
147 (z_out) = U32(op(_t)); (c_out) = _t >> 32; \
148 } while (0)
149 #else
150 # define BLKC_ADDC32(op, z_out, c_out, x, y) do { \
151 uint32 _x = op(x), _c = 0, _t; \
152 _t = U32(_x + (y)); (z_out) = op(_t); (c_out) = (_t < _x); \
153 } while (0)
154 #endif
155
156 /* --- General implementation skeleton --- */
157
158 #define BLKC_SKEL(PRE, decl, guts) do { \
159 decl \
160 guts \
161 } while (0)
162
163 #define BLKC_P(p) octet *_p = (octet *)(p)
164 #define BLKC_W(w) uint32 *_w = (w)
165 #define BLKC_WX(wx) uint32 *_wx = (wx)
166
167 /* --- Implementation for unusual block sizes --- */
168
169 #define BLKC_SKEL_X(PRE, decl, guts) \
170 BLKC_SKEL(PRE, unsigned _i; decl, \
171 for (_i = 0; _i < PRE##_BLKSZ/4; _i++) { \
172 guts \
173 })
174
175 #define BLKC_STORE_X(PRE, b, w, op, n) \
176 BLKC_SKEL_X(PRE, BLKC_P(b); const BLKC_W(w);, \
177 op(_p, *_w); _p += 4; _w++; )
178
179 #define BLKC_XSTORE_X(PRE, b, w, wx, op, n) \
180 BLKC_SKEL_X(PRE, BLKC_P(b); const BLKC_W(w); const BLKC_WX(wx);, \
181 op(_p, *_w ^ *_wx); _p += 4; _w++; _wx++; )
182
183 #define BLKC_LOAD_X(PRE, w, b, op, n) \
184 BLKC_SKEL_X(PRE, const BLKC_P(b); BLKC_W(w);, \
185 *_w = op(_p); _p += 4; _w++; )
186
187 #define BLKC_XLOAD_X(PRE, w, b, op, n) \
188 BLKC_SKEL_X(PRE, const BLKC_P(b); BLKC_W(w);, \
189 *_w ^= op(_p); _p += 4; _w++; )
190
191 #define BLKC_MOVE_X(PRE, w, wx, n) \
192 BLKC_SKEL_X(PRE, BLKC_W(w); const BLKC_WX(wx);, \
193 *_w = *_wx; _w++; _wx++; ) \
194
195 #define BLKC_XMOVE_X(PRE, w, wx, n) \
196 BLKC_SKEL_X(PRE, BLKC_W(w); const BLKC_WX(wx);, \
197 *_w ^= *_wx; _w++; _wx++; ) \
198
199 #define BLKC_ZERO_X(PRE, w, n) \
200 BLKC_SKEL_X(PRE, BLKC_W(w);, *_w++ = 0;)
201
202 #define BLKC_BADD_X_B(PRE, w, n) BLKC_ADD_X_B(PRE, BLKC_ID, w, n)
203 #define BLKC_BADD_X_L(PRE, w, n) BLKC_ADD_X_B(PRE, ENDSWAP32, w, n)
204 #define BLKC_LADD_X_B(PRE, w, n) BLKC_ADD_X_L(PRE, ENDSWAP32, w, n)
205 #define BLKC_LADD_X_L(PRE, w, n) BLKC_ADD_X_L(PRE, BLKC_ID, w, n)
206
207 #define BLKC_ADD_X_B(PRE, op, w, n) do { \
208 unsigned _i = PRE##_BLKSZ/4; BLKC_W(w); uint32 _n = (n); \
209 while (_i-- && _n) BLKC_ADDC32(op, _w[_i], _n, _w[_i], _n); \
210 } while (0)
211
212 #define BLKC_ADD_X_L(PRE, op, w, n) do { \
213 unsigned _i = 0; BLKC_W(w); uint32 _n = (n); \
214 while (_i < PRE##_BLKSZ/4 && _n) \
215 { BLKC_ADDC32(op, _w[_i], _n, _w[_i], _n); _i++; } \
216 } while (0)
217
218 #define BLKC_BSET_X_B(PRE, w, x) BLKC_SET_X_B(PRE, BLKC_ID, w, x)
219 #define BLKC_BSET_X_L(PRE, w, x) BLKC_SET_X_B(PRE, ENDSWAP32, w, x)
220 #define BLKC_LSET_X_B(PRE, w, x) BLKC_SET_X_L(PRE, ENDSWAP32, w, x)
221 #define BLKC_LSET_X_L(PRE, w, x) BLKC_SET_X_L(PRE, BLKC_ID, w, x)
222
223 #define BLKC_SET_X_B(PRE, op, w, x) do { \
224 unsigned _i; BLKC_W(w); unsigned long _x = x; _w += PRE##_BLKSZ/4; \
225 for (_i = 0; _i < PRE##_BLKSZ/4; _i++) { \
226 *--_w = U32(op(_x)); \
227 _x = ((_x & ~(unsigned long)MASK32) >> 16) >> 16; \
228 } \
229 } while (0)
230
231 #define BLKC_SET_X_L(PRE, op, w, x) do { \
232 unsigned _i; BLKC_W(w); unsigned long _x = x; \
233 for (_i = 0; _i < PRE##_BLKSZ/4; _i++) { \
234 *_w++ = U32(op(_x)); \
235 _x = ((_x & ~(unsigned long)MASK32) >> 16) >> 16; \
236 } \
237 } while (0)
238
239 #define BLKC_BWORD_B(x) (x)
240 #define BLKC_BWORD_L(x) ENDSWAP32(x)
241 #define BLKC_LWORD_B(x) ENDSWAP32(x)
242 #define BLKC_LWORD_L(x) (x)
243
244 /* --- Implementation for known block sizes --- */
245
246 #define BLKC_SKEL_64(PRE, decl, op, guts) \
247 BLKC_SKEL(PRE, decl, guts(op, 0); guts(op, 1);)
248
249 #define BLKC_SKEL_96(PRE, decl, op, guts) \
250 BLKC_SKEL(PRE, decl, guts(op, 0); guts(op, 1); guts(op, 2);)
251
252 #define BLKC_SKEL_128(PRE, decl, op, guts) \
253 BLKC_SKEL(PRE, decl, guts(op, 0); guts(op, 1); guts(op, 2); guts(op, 3);)
254
255 #define BLKC_SKEL_192(PRE, decl, op, guts) \
256 BLKC_SKEL(PRE, decl, \
257 guts(op, 0); guts(op, 1); guts(op, 2); guts(op, 3); \
258 guts(op, 4); guts(op, 5);)
259
260 #define BLKC_SKEL_256(PRE, decl, op, guts) \
261 BLKC_SKEL(PRE, decl, \
262 guts(op, 0); guts(op, 1); guts(op, 2); guts(op, 3); \
263 guts(op, 4); guts(op, 5); guts(op, 6); guts(op, 7);)
264
265 #define BLKC_STORE_GUTS(op, i) op(_p + 4 * i, _w[i])
266 #define BLKC_XSTORE_GUTS(op, i) op(_p + 4 * i, _w[i] ^ _wx[i])
267 #define BLKC_LOAD_GUTS(op, i) _w[i] = op(_p + 4 * i)
268 #define BLKC_XLOAD_GUTS(op, i) _w[i] ^= op(_p + 4 * i)
269 #define BLKC_MOVE_GUTS(op, i) _w[i] = _wx[i]
270 #define BLKC_XMOVE_GUTS(op, i) _w[i] ^= _wx[i]
271 #define BLKC_ZERO_GUTS(op, i) _w[i] = 0
272
273 #define BLKC_STORE_N(PRE, b, w, op, n) \
274 BLKC_GLUE(BLKC_SKEL_, n) \
275 (PRE, BLKC_P(b); const BLKC_W(w);, op, BLKC_STORE_GUTS)
276
277 #define BLKC_XSTORE_N(PRE, b, w, wx, op, n) \
278 BLKC_GLUE(BLKC_SKEL_, n) \
279 (PRE, BLKC_P(b); const BLKC_W(w); const BLKC_WX(wx);, \
280 op, BLKC_XSTORE_GUTS)
281
282 #define BLKC_LOAD_N(PRE, w, b, op, n) \
283 BLKC_GLUE(BLKC_SKEL_, n) \
284 (PRE, const BLKC_P(b); BLKC_W(w);, op, BLKC_LOAD_GUTS)
285
286 #define BLKC_XLOAD_N(PRE, w, b, op, n) \
287 BLKC_GLUE(BLKC_SKEL_, n) \
288 (PRE, const BLKC_P(b); BLKC_W(w);, op, BLKC_XLOAD_GUTS)
289
290 #define BLKC_MOVE_N(PRE, w, wx, n) \
291 BLKC_GLUE(BLKC_SKEL_, n) \
292 (PRE, BLKC_W(w); const BLKC_WX(wx);, op, BLKC_MOVE_GUTS)
293
294 #define BLKC_ZERO_N(PRE, w, n) \
295 BLKC_GLUE(BLKC_SKEL_, n) \
296 (PRE, BLKC_W(w); , op, BLKC_ZERO_GUTS)
297
298 #define BLKC_XMOVE_N(PRE, w, wx, n) \
299 BLKC_GLUE(BLKC_SKEL_, n) \
300 (PRE, BLKC_W(w); const BLKC_WX(wx);, op, BLKC_XMOVE_GUTS)
301
302 /*----- Binary field arithmetic -------------------------------------------*/
303
304 #define BLKC_POLY_IRRED64 0x001b
305 #define BLKC_POLY_IRRED96 0x0641
306 #define BLKC_POLY_IRRED128 0x0087
307 #define BLKC_POLY_IRRED192 0x0087
308 #define BLKC_POLY_IRRED256 0x0425
309
310 #define BLKC_POLY_PRIM64 0x001b
311 #define BLKC_POLY_PRIM96 0x0641
312 #define BLKC_POLY_PRIM128 0x0087
313 #define BLKC_POLY_PRIM192 0x8821
314 #define BLKC_POLY_PRIM256 0x0425
315
316 #define BLKC_POLY(PRE, f) BLKC_GLUE(BLKC_POLY_##f, BLKC_BITS(PRE))
317
318 #define BLKC_BLSHIFT(PRE, f, z, x) \
319 BLKC_GLUE(BLKC_BLSHIFT_X_, BLKC_ENDIAN(PRE)) \
320 (PRE, f, z, x)
321 #define BLKC_LLSHIFT(PRE, f, z, x) \
322 BLKC_GLUE(BLKC_LLSHIFT_X_, BLKC_ENDIAN(PRE)) \
323 (PRE, f, z, x)
324 #define BLKC_LSHIFT(PRE, f, z, x) \
325 BLKC_GLUE(BLKC_LSHIFT_X_, BLKC_ENDIAN(PRE)) \
326 (PRE, BLKC_ID, f, z, x)
327
328 #define BLKC_BRSHIFT(PRE, f, z, x) \
329 BLKC_GLUE(BLKC_BRSHIFT_X_, BLKC_ENDIAN(PRE)) \
330 (PRE, f, z, x)
331 #define BLKC_LRSHIFT(PRE, f, z, x) \
332 BLKC_GLUE(BLKC_LRSHIFT_X_, BLKC_ENDIAN(PRE)) \
333 (PRE, f, z, x)
334 #define BLKC_RSHIFT(PRE, f, z, x) \
335 BLKC_GLUE(BLKC_RSHIFT_X_, BLKC_ENDIAN(PRE)) \
336 (PRE, BLKC_ID, f, z, x)
337
338 #define BLKC_BLSHIFT_X_B(PRE, f, z, x) BLKC_LSHIFT_X_B(PRE, BLKC_ID, f, z, x)
339 #define BLKC_LLSHIFT_X_B(PRE, f, z, x) BLKC_LSHIFT_X_L(PRE, ENDSWAP32, f, z, x)
340 #define BLKC_BLSHIFT_X_L(PRE, f, z, x) BLKC_LSHIFT_X_B(PRE, ENDSWAP32, f, z, x)
341 #define BLKC_LLSHIFT_X_L(PRE, f, z, x) BLKC_LSHIFT_X_L(PRE, BLKC_ID, f, z, x)
342
343 #define BLKC_BRSHIFT_X_B(PRE, f, z, x) BLKC_RSHIFT_X_B(PRE, BLKC_ID, f, z, x)
344 #define BLKC_LRSHIFT_X_B(PRE, f, z, x) BLKC_RSHIFT_X_L(PRE, ENDSWAP32, f, z, x)
345 #define BLKC_BRSHIFT_X_L(PRE, f, z, x) BLKC_RSHIFT_X_B(PRE, ENDSWAP32, f, z, x)
346 #define BLKC_LRSHIFT_X_L(PRE, f, z, x) BLKC_RSHIFT_X_L(PRE, BLKC_ID, f, z, x)
347
348 #define BLKC_LSHIFT_X_B(PRE, op, f, z, x) do { \
349 uint32 *_z = (z); const uint32 *_x = (x); \
350 uint32 _t = op(_x[0]), _m = -(uint32)((_t >> 31)&1u), \
351 _c = BLKC_POLY(PRE, f)&_m; \
352 unsigned _i; \
353 \
354 for (_i = PRE##_BLKSZ/4; _i-- > 0; ) \
355 { _t = op(_x[_i]); _z[_i] = op((_t << 1) ^ _c); _c = (_t >> 31)&1u; } \
356 } while (0)
357
358 #define BLKC_RSHIFT_X_B(PRE, op, f, z, x) do { \
359 uint32 *_z = (z); const uint32 *_x = (x); \
360 uint32 _t, _t0 = op(_x[PRE##_BLKSZ/4 - 1]), _m = -(uint32)(_t0&1u), \
361 _c = 0x80000000&_m; \
362 unsigned _i; \
363 \
364 for (_i = 0; _i < PRE##_BLKSZ/4 - 1; _i++) \
365 { _t = op(_x[_i]); _z[_i] = op((_t >> 1) ^ _c); _c = (_t&1u) << 31; } \
366 _t0 ^= BLKC_POLY(PRE, f)&_m; _z[PRE##_BLKSZ/4 - 1] = op((_t0 >> 1) ^ _c); \
367 } while (0)
368
369 #define BLKC_LSHIFT_X_L(PRE, op, f, z, x) do { \
370 uint32 *_z = (z); const uint32 *_x = (x); \
371 uint32 _t = op(_x[PRE##_BLKSZ/4 - 1]), _m = -(uint32)((_t >> 31)&1u), \
372 _c = BLKC_POLY(PRE, f)&_m; \
373 unsigned _i; \
374 \
375 for (_i = 0; _i < PRE##_BLKSZ/4; _i++) \
376 { _t = op(_x[_i]); _z[_i] = op((_t << 1) ^ _c); _c = (_t >> 31)&1u; } \
377 } while (0)
378
379 #define BLKC_RSHIFT_X_L(PRE, op, f, z, x) do { \
380 uint32 *_z = (z); const uint32 *_x = (x); \
381 uint32 _t, _t0 = op(_x[0]), _m = -(uint32)(_t0&1u), \
382 _c = 0x80000000&_m; \
383 unsigned _i; \
384 \
385 for (_i = PRE##_BLKSZ/4 - 1; _i-- > 1; ) \
386 { _t = op(_x[_i]); _z[_i] = op((_t >> 1) ^ _c); _c = (_t&1u) << 31; } \
387 _t0 ^= BLKC_POLY(PRE, f)&_m; _z[0] = op((_t0 >> 1) ^ _c); \
388 } while (0)
389
390 /*----- Test rig for block ciphers ----------------------------------------*/
391
392 /* --- @BLKC_TEST@ --- *
393 *
394 * Arguments: @PRE@, @pre@ = prefixes for cipher-specific definitions
395 *
396 * Use: Standard test rig for block ciphers.
397 */
398
399 #ifdef TEST_RIG
400
401 #include <string.h>
402
403 #include <mLib/macros.h>
404 #include <mLib/quis.h>
405 #include <mLib/testrig.h>
406
407 #ifndef BLKC_TESTHOOK
408 # define BLKC_TESTHOOK do ; while (0)
409 #endif
410
411 #define BLKC_VERIFY(PRE, pre) BLKC_VERIFYX(PRE, pre, #pre)
412
413 #define BLKC_VERIFYX(PRE, pre, name) \
414 \
415 static int pre##_verify(dstr *v) \
416 { \
417 pre##_ctx k; \
418 uint32 p[PRE##_BLKSZ/4]; \
419 uint32 c[PRE##_BLKSZ/4]; \
420 uint32 d[PRE##_BLKSZ/4]; \
421 dstr b = DSTR_INIT; \
422 int ok = 1; \
423 \
424 /* --- Initialize the key buffer --- */ \
425 \
426 dstr_ensure(&b, PRE##_BLKSZ); \
427 b.len = PRE##_BLKSZ; \
428 pre##_init(&k, v[0].buf, v[0].len); \
429 BLKC_LOAD(PRE, p, v[1].buf); \
430 BLKC_LOAD(PRE, c, v[2].buf); \
431 \
432 /* --- Test encryption --- */ \
433 \
434 BLKC_MOVE(PRE, d, p); \
435 pre##_eblk(&k, d, d); \
436 BLKC_STORE(PRE, b.buf, d); \
437 if (MEMCMP(b.buf, !=, v[2].buf, PRE##_BLKSZ)) { \
438 ok = 0; \
439 printf("\nfail encryption:" \
440 "\n\tkey = "); \
441 type_hex.dump(&v[0], stdout); \
442 printf("\n\tplaintext = "); type_hex.dump(&v[1], stdout); \
443 printf("\n\texpected = "); type_hex.dump(&v[2], stdout); \
444 printf("\n\tcalculated = "); type_hex.dump(&b, stdout); \
445 putchar('\n'); \
446 } \
447 \
448 /* --- Test decryption --- */ \
449 \
450 BLKC_MOVE(PRE, d, c); \
451 pre##_dblk(&k, d, d); \
452 BLKC_STORE(PRE, b.buf, d); \
453 if (MEMCMP(b.buf, !=, v[1].buf, PRE##_BLKSZ)) { \
454 ok = 0; \
455 printf("\nfail decryption:" \
456 "\n\tkey = "); \
457 type_hex.dump(&v[0], stdout); \
458 printf("\n\tciphertext = "); type_hex.dump(&v[2], stdout); \
459 printf("\n\texpected = "); type_hex.dump(&v[1], stdout); \
460 printf("\n\tcalculated = "); type_hex.dump(&b, stdout); \
461 putchar('\n'); \
462 } \
463 \
464 /* --- Return --- */ \
465 \
466 return (ok); \
467 }
468
469 #define BLKC_TESTDEFS(PRE, pre) BLKC_TESTDEFSX(PRE, pre, #pre)
470
471 #define BLKC_TESTDEFSX(PRE, pre, name) \
472 { name, pre##_verify, { &type_hex, &type_hex, &type_hex, 0 } },
473
474 #define BLKC_TESTX(PRE, pre, name, fname) \
475 \
476 BLKC_VERIFYX(PRE, pre, name) \
477 \
478 static const test_chunk defs[] = { \
479 BLKC_TESTDEFSX(PRE, pre, name) \
480 { 0, 0, { 0 } } \
481 }; \
482 \
483 int main(int argc, char *argv[]) \
484 { \
485 BLKC_TESTHOOK; \
486 test_run(argc, argv, defs, SRCDIR"/t/" fname); \
487 return (0); \
488 }
489
490 #else
491 # define BLKC_TESTX(PRE, pre, name, fname)
492 #endif
493
494 #define BLKC_TEST(PRE, pre) BLKC_TESTX(PRE, pre, #pre, #pre)
495
496 /*----- That's all, folks -------------------------------------------------*/
497
498 #ifdef __cplusplus
499 }
500 #endif
501
502 #endif
Catacomb cryptographic library