Remove the special list-xxxx commands
[openssl.git] / test / igetest.c
1 /* test/igetest.c -*- mode:C; c-file-style: "eay" -*- */
2 /* ====================================================================
3  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in
14  *    the documentation and/or other materials provided with the
15  *    distribution.
16  *
17  * 3. All advertising materials mentioning features or use of this
18  *    software must display the following acknowledgment:
19  *    "This product includes software developed by the OpenSSL Project
20  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
21  *
22  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
23  *    endorse or promote products derived from this software without
24  *    prior written permission. For written permission, please contact
25  *    openssl-core@openssl.org.
26  *
27  * 5. Products derived from this software may not be called "OpenSSL"
28  *    nor may "OpenSSL" appear in their names without prior written
29  *    permission of the OpenSSL Project.
30  *
31  * 6. Redistributions of any form whatsoever must retain the following
32  *    acknowledgment:
33  *    "This product includes software developed by the OpenSSL Project
34  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
35  *
36  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
37  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
38  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
39  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
40  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
42  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
43  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
44  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
45  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
46  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
47  * OF THE POSSIBILITY OF SUCH DAMAGE.
48  * ====================================================================
49  *
50  */
51
52 #include <openssl/crypto.h>
53 #include <openssl/aes.h>
54 #include <openssl/rand.h>
55 #include <stdio.h>
56 #include <string.h>
57 #include <assert.h>
58
59 #define TEST_SIZE       128
60 #define BIG_TEST_SIZE 10240
61
62 static void hexdump(FILE *f, const char *title, const unsigned char *s, int l)
63 {
64     int n = 0;
65
66     fprintf(f, "%s", title);
67     for (; n < l; ++n) {
68         if ((n % 16) == 0)
69             fprintf(f, "\n%04x", n);
70         fprintf(f, " %02x", s[n]);
71     }
72     fprintf(f, "\n");
73 }
74
75 #define MAX_VECTOR_SIZE 64
76
77 struct ige_test {
78     const unsigned char key[16];
79     const unsigned char iv[32];
80     const unsigned char in[MAX_VECTOR_SIZE];
81     const unsigned char out[MAX_VECTOR_SIZE];
82     const size_t length;
83     const int encrypt;
84 };
85
86 static struct ige_test const ige_test_vectors[] = {
87     {{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
88       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}, /* key */
89      {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
90       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
91       0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
92       0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f}, /* iv */
93      {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
94       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
95       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
96       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* in */
97      {0x1a, 0x85, 0x19, 0xa6, 0x55, 0x7b, 0xe6, 0x52,
98       0xe9, 0xda, 0x8e, 0x43, 0xda, 0x4e, 0xf4, 0x45,
99       0x3c, 0xf4, 0x56, 0xb4, 0xca, 0x48, 0x8a, 0xa3,
100       0x83, 0xc7, 0x9c, 0x98, 0xb3, 0x47, 0x97, 0xcb}, /* out */
101      32, AES_ENCRYPT},          /* test vector 0 */
102
103     {{0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20,
104       0x61, 0x6e, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65}, /* key */
105      {0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f,
106       0x6e, 0x20, 0x6f, 0x66, 0x20, 0x49, 0x47, 0x45,
107       0x20, 0x6d, 0x6f, 0x64, 0x65, 0x20, 0x66, 0x6f,
108       0x72, 0x20, 0x4f, 0x70, 0x65, 0x6e, 0x53, 0x53}, /* iv */
109      {0x4c, 0x2e, 0x20, 0x4c, 0x65, 0x74, 0x27, 0x73,
110       0x20, 0x68, 0x6f, 0x70, 0x65, 0x20, 0x42, 0x65,
111       0x6e, 0x20, 0x67, 0x6f, 0x74, 0x20, 0x69, 0x74,
112       0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x21, 0x0a}, /* in */
113      {0x99, 0x70, 0x64, 0x87, 0xa1, 0xcd, 0xe6, 0x13,
114       0xbc, 0x6d, 0xe0, 0xb6, 0xf2, 0x4b, 0x1c, 0x7a,
115       0xa4, 0x48, 0xc8, 0xb9, 0xc3, 0x40, 0x3e, 0x34,
116       0x67, 0xa8, 0xca, 0xd8, 0x93, 0x40, 0xf5, 0x3b}, /* out */
117      32, AES_DECRYPT},          /* test vector 1 */
118 };
119
120 struct bi_ige_test {
121     const unsigned char key1[32];
122     const unsigned char key2[32];
123     const unsigned char iv[64];
124     const unsigned char in[MAX_VECTOR_SIZE];
125     const unsigned char out[MAX_VECTOR_SIZE];
126     const size_t keysize;
127     const size_t length;
128     const int encrypt;
129 };
130
131 static struct bi_ige_test const bi_ige_test_vectors[] = {
132     {{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
133       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}, /* key1 */
134      {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
135       0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f}, /* key2 */
136      {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
137       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
138       0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
139       0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
140       0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
141       0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
142       0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
143       0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f}, /* iv */
144      {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
145       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
146       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
147       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* in */
148      {0x14, 0x40, 0x6f, 0xae, 0xa2, 0x79, 0xf2, 0x56,
149       0x1f, 0x86, 0xeb, 0x3b, 0x7d, 0xff, 0x53, 0xdc,
150       0x4e, 0x27, 0x0c, 0x03, 0xde, 0x7c, 0xe5, 0x16,
151       0x6a, 0x9c, 0x20, 0x33, 0x9d, 0x33, 0xfe, 0x12}, /* out */
152      16, 32, AES_ENCRYPT},      /* test vector 0 */
153     {{0x58, 0x0a, 0x06, 0xe9, 0x97, 0x07, 0x59, 0x5c,
154       0x9e, 0x19, 0xd2, 0xa7, 0xbb, 0x40, 0x2b, 0x7a,
155       0xc7, 0xd8, 0x11, 0x9e, 0x4c, 0x51, 0x35, 0x75,
156       0x64, 0x28, 0x0f, 0x23, 0xad, 0x74, 0xac, 0x37}, /* key1 */
157      {0xd1, 0x80, 0xa0, 0x31, 0x47, 0xa3, 0x11, 0x13,
158       0x86, 0x26, 0x9e, 0x6d, 0xff, 0xaf, 0x72, 0x74,
159       0x5b, 0xa2, 0x35, 0x81, 0xd2, 0xa6, 0x3d, 0x21,
160       0x67, 0x7b, 0x58, 0xa8, 0x18, 0xf9, 0x72, 0xe4}, /* key2 */
161      {0x80, 0x3d, 0xbd, 0x4c, 0xe6, 0x7b, 0x06, 0xa9,
162       0x53, 0x35, 0xd5, 0x7e, 0x71, 0xc1, 0x70, 0x70,
163       0x74, 0x9a, 0x00, 0x28, 0x0c, 0xbf, 0x6c, 0x42,
164       0x9b, 0xa4, 0xdd, 0x65, 0x11, 0x77, 0x7c, 0x67,
165       0xfe, 0x76, 0x0a, 0xf0, 0xd5, 0xc6, 0x6e, 0x6a,
166       0xe7, 0x5e, 0x4c, 0xf2, 0x7e, 0x9e, 0xf9, 0x20,
167       0x0e, 0x54, 0x6f, 0x2d, 0x8a, 0x8d, 0x7e, 0xbd,
168       0x48, 0x79, 0x37, 0x99, 0xff, 0x27, 0x93, 0xa3}, /* iv */
169      {0xf1, 0x54, 0x3d, 0xca, 0xfe, 0xb5, 0xef, 0x1c,
170       0x4f, 0xa6, 0x43, 0xf6, 0xe6, 0x48, 0x57, 0xf0,
171       0xee, 0x15, 0x7f, 0xe3, 0xe7, 0x2f, 0xd0, 0x2f,
172       0x11, 0x95, 0x7a, 0x17, 0x00, 0xab, 0xa7, 0x0b,
173       0xbe, 0x44, 0x09, 0x9c, 0xcd, 0xac, 0xa8, 0x52,
174       0xa1, 0x8e, 0x7b, 0x75, 0xbc, 0xa4, 0x92, 0x5a,
175       0xab, 0x46, 0xd3, 0x3a, 0xa0, 0xd5, 0x35, 0x1c,
176       0x55, 0xa4, 0xb3, 0xa8, 0x40, 0x81, 0xa5, 0x0b}, /* in */
177      {0x42, 0xe5, 0x28, 0x30, 0x31, 0xc2, 0xa0, 0x23,
178       0x68, 0x49, 0x4e, 0xb3, 0x24, 0x59, 0x92, 0x79,
179       0xc1, 0xa5, 0xcc, 0xe6, 0x76, 0x53, 0xb1, 0xcf,
180       0x20, 0x86, 0x23, 0xe8, 0x72, 0x55, 0x99, 0x92,
181       0x0d, 0x16, 0x1c, 0x5a, 0x2f, 0xce, 0xcb, 0x51,
182       0xe2, 0x67, 0xfa, 0x10, 0xec, 0xcd, 0x3d, 0x67,
183       0xa5, 0xe6, 0xf7, 0x31, 0x26, 0xb0, 0x0d, 0x76,
184       0x5e, 0x28, 0xdc, 0x7f, 0x01, 0xc5, 0xa5, 0x4c}, /* out */
185      32, 64, AES_ENCRYPT},      /* test vector 1 */
186
187 };
188
189 static int run_test_vectors(void)
190 {
191     unsigned int n;
192     int errs = 0;
193
194     for (n = 0; n < sizeof(ige_test_vectors) / sizeof(ige_test_vectors[0]);
195          ++n) {
196         const struct ige_test *const v = &ige_test_vectors[n];
197         AES_KEY key;
198         unsigned char buf[MAX_VECTOR_SIZE];
199         unsigned char iv[AES_BLOCK_SIZE * 2];
200
201         assert(v->length <= MAX_VECTOR_SIZE);
202
203         if (v->encrypt == AES_ENCRYPT)
204             AES_set_encrypt_key(v->key, 8 * sizeof v->key, &key);
205         else
206             AES_set_decrypt_key(v->key, 8 * sizeof v->key, &key);
207         memcpy(iv, v->iv, sizeof iv);
208         AES_ige_encrypt(v->in, buf, v->length, &key, iv, v->encrypt);
209
210         if (memcmp(v->out, buf, v->length)) {
211             printf("IGE test vector %d failed\n", n);
212             hexdump(stdout, "key", v->key, sizeof v->key);
213             hexdump(stdout, "iv", v->iv, sizeof v->iv);
214             hexdump(stdout, "in", v->in, v->length);
215             hexdump(stdout, "expected", v->out, v->length);
216             hexdump(stdout, "got", buf, v->length);
217
218             ++errs;
219         }
220
221         /* try with in == out */
222         memcpy(iv, v->iv, sizeof iv);
223         memcpy(buf, v->in, v->length);
224         AES_ige_encrypt(buf, buf, v->length, &key, iv, v->encrypt);
225
226         if (memcmp(v->out, buf, v->length)) {
227             printf("IGE test vector %d failed (with in == out)\n", n);
228             hexdump(stdout, "key", v->key, sizeof v->key);
229             hexdump(stdout, "iv", v->iv, sizeof v->iv);
230             hexdump(stdout, "in", v->in, v->length);
231             hexdump(stdout, "expected", v->out, v->length);
232             hexdump(stdout, "got", buf, v->length);
233
234             ++errs;
235         }
236     }
237
238     for (n = 0;
239          n < sizeof(bi_ige_test_vectors) / sizeof(bi_ige_test_vectors[0]);
240          ++n) {
241         const struct bi_ige_test *const v = &bi_ige_test_vectors[n];
242         AES_KEY key1;
243         AES_KEY key2;
244         unsigned char buf[MAX_VECTOR_SIZE];
245
246         assert(v->length <= MAX_VECTOR_SIZE);
247
248         if (v->encrypt == AES_ENCRYPT) {
249             AES_set_encrypt_key(v->key1, 8 * v->keysize, &key1);
250             AES_set_encrypt_key(v->key2, 8 * v->keysize, &key2);
251         } else {
252             AES_set_decrypt_key(v->key1, 8 * v->keysize, &key1);
253             AES_set_decrypt_key(v->key2, 8 * v->keysize, &key2);
254         }
255
256         AES_bi_ige_encrypt(v->in, buf, v->length, &key1, &key2, v->iv,
257                            v->encrypt);
258
259         if (memcmp(v->out, buf, v->length)) {
260             printf("Bidirectional IGE test vector %d failed\n", n);
261             hexdump(stdout, "key 1", v->key1, sizeof v->key1);
262             hexdump(stdout, "key 2", v->key2, sizeof v->key2);
263             hexdump(stdout, "iv", v->iv, sizeof v->iv);
264             hexdump(stdout, "in", v->in, v->length);
265             hexdump(stdout, "expected", v->out, v->length);
266             hexdump(stdout, "got", buf, v->length);
267
268             ++errs;
269         }
270     }
271
272     return errs;
273 }
274
275 int main(int argc, char **argv)
276 {
277     unsigned char rkey[16];
278     unsigned char rkey2[16];
279     AES_KEY key;
280     AES_KEY key2;
281     unsigned char plaintext[BIG_TEST_SIZE];
282     unsigned char ciphertext[BIG_TEST_SIZE];
283     unsigned char checktext[BIG_TEST_SIZE];
284     unsigned char iv[AES_BLOCK_SIZE * 4];
285     unsigned char saved_iv[AES_BLOCK_SIZE * 4];
286     int err = 0;
287     unsigned int n;
288     unsigned matches;
289
290     assert(BIG_TEST_SIZE >= TEST_SIZE);
291
292     RAND_bytes(rkey, sizeof rkey);
293     RAND_bytes(plaintext, sizeof plaintext);
294     RAND_bytes(iv, sizeof iv);
295     memcpy(saved_iv, iv, sizeof saved_iv);
296
297     /* Forward IGE only... */
298
299     /* Straight encrypt/decrypt */
300     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
301     AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE, &key, iv, AES_ENCRYPT);
302
303     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
304     memcpy(iv, saved_iv, sizeof iv);
305     AES_ige_encrypt(ciphertext, checktext, TEST_SIZE, &key, iv, AES_DECRYPT);
306
307     if (memcmp(checktext, plaintext, TEST_SIZE)) {
308         printf("Encrypt+decrypt doesn't match\n");
309         hexdump(stdout, "Plaintext", plaintext, TEST_SIZE);
310         hexdump(stdout, "Checktext", checktext, TEST_SIZE);
311         ++err;
312     }
313
314     /* Now check encrypt chaining works */
315     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
316     memcpy(iv, saved_iv, sizeof iv);
317     AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE / 2, &key, iv,
318                     AES_ENCRYPT);
319     AES_ige_encrypt(plaintext + TEST_SIZE / 2,
320                     ciphertext + TEST_SIZE / 2, TEST_SIZE / 2,
321                     &key, iv, AES_ENCRYPT);
322
323     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
324     memcpy(iv, saved_iv, sizeof iv);
325     AES_ige_encrypt(ciphertext, checktext, TEST_SIZE, &key, iv, AES_DECRYPT);
326
327     if (memcmp(checktext, plaintext, TEST_SIZE)) {
328         printf("Chained encrypt+decrypt doesn't match\n");
329         hexdump(stdout, "Plaintext", plaintext, TEST_SIZE);
330         hexdump(stdout, "Checktext", checktext, TEST_SIZE);
331         ++err;
332     }
333
334     /* And check decrypt chaining */
335     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
336     memcpy(iv, saved_iv, sizeof iv);
337     AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE / 2, &key, iv,
338                     AES_ENCRYPT);
339     AES_ige_encrypt(plaintext + TEST_SIZE / 2,
340                     ciphertext + TEST_SIZE / 2, TEST_SIZE / 2,
341                     &key, iv, AES_ENCRYPT);
342
343     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
344     memcpy(iv, saved_iv, sizeof iv);
345     AES_ige_encrypt(ciphertext, checktext, TEST_SIZE / 2, &key, iv,
346                     AES_DECRYPT);
347     AES_ige_encrypt(ciphertext + TEST_SIZE / 2,
348                     checktext + TEST_SIZE / 2, TEST_SIZE / 2, &key, iv,
349                     AES_DECRYPT);
350
351     if (memcmp(checktext, plaintext, TEST_SIZE)) {
352         printf("Chained encrypt+chained decrypt doesn't match\n");
353         hexdump(stdout, "Plaintext", plaintext, TEST_SIZE);
354         hexdump(stdout, "Checktext", checktext, TEST_SIZE);
355         ++err;
356     }
357
358     /* make sure garble extends forwards only */
359     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
360     memcpy(iv, saved_iv, sizeof iv);
361     AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
362                     AES_ENCRYPT);
363
364     /* corrupt halfway through */
365     ++ciphertext[sizeof ciphertext / 2];
366     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
367     memcpy(iv, saved_iv, sizeof iv);
368     AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
369                     AES_DECRYPT);
370
371     matches = 0;
372     for (n = 0; n < sizeof checktext; ++n)
373         if (checktext[n] == plaintext[n])
374             ++matches;
375
376     if (matches > sizeof checktext / 2 + sizeof checktext / 100) {
377         printf("More than 51%% matches after garbling\n");
378         ++err;
379     }
380
381     if (matches < sizeof checktext / 2) {
382         printf("Garble extends backwards!\n");
383         ++err;
384     }
385
386     /* Bi-directional IGE */
387
388     /*
389      * Note that we don't have to recover the IV, because chaining isn't
390      */
391     /* possible with biIGE, so the IV is not updated. */
392
393     RAND_bytes(rkey2, sizeof rkey2);
394
395     /* Straight encrypt/decrypt */
396     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
397     AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
398     AES_bi_ige_encrypt(plaintext, ciphertext, TEST_SIZE, &key, &key2, iv,
399                        AES_ENCRYPT);
400
401     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
402     AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
403     AES_bi_ige_encrypt(ciphertext, checktext, TEST_SIZE, &key, &key2, iv,
404                        AES_DECRYPT);
405
406     if (memcmp(checktext, plaintext, TEST_SIZE)) {
407         printf("Encrypt+decrypt doesn't match\n");
408         hexdump(stdout, "Plaintext", plaintext, TEST_SIZE);
409         hexdump(stdout, "Checktext", checktext, TEST_SIZE);
410         ++err;
411     }
412
413     /* make sure garble extends both ways */
414     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
415     AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
416     AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
417                     AES_ENCRYPT);
418
419     /* corrupt halfway through */
420     ++ciphertext[sizeof ciphertext / 2];
421     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
422     AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
423     AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
424                     AES_DECRYPT);
425
426     matches = 0;
427     for (n = 0; n < sizeof checktext; ++n)
428         if (checktext[n] == plaintext[n])
429             ++matches;
430
431     if (matches > sizeof checktext / 100) {
432         printf("More than 1%% matches after bidirectional garbling\n");
433         ++err;
434     }
435
436     /* make sure garble extends both ways (2) */
437     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
438     AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
439     AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
440                     AES_ENCRYPT);
441
442     /* corrupt right at the end */
443     ++ciphertext[sizeof ciphertext - 1];
444     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
445     AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
446     AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
447                     AES_DECRYPT);
448
449     matches = 0;
450     for (n = 0; n < sizeof checktext; ++n)
451         if (checktext[n] == plaintext[n])
452             ++matches;
453
454     if (matches > sizeof checktext / 100) {
455         printf("More than 1%% matches after bidirectional garbling (2)\n");
456         ++err;
457     }
458
459     /* make sure garble extends both ways (3) */
460     AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
461     AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
462     AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
463                     AES_ENCRYPT);
464
465     /* corrupt right at the start */
466     ++ciphertext[0];
467     AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
468     AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
469     AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
470                     AES_DECRYPT);
471
472     matches = 0;
473     for (n = 0; n < sizeof checktext; ++n)
474         if (checktext[n] == plaintext[n])
475             ++matches;
476
477     if (matches > sizeof checktext / 100) {
478         printf("More than 1%% matches after bidirectional garbling (3)\n");
479         ++err;
480     }
481
482     err += run_test_vectors();
483
484     return err;
485 }