chiark / gitweb /
Makefile.in: turn of -Wsign-compare for bison output
[secnet] / eax-test.c
1 /*
2  * eax-test.c: test harness for EAX, implementation
3  */
4 /*
5  * This file is Free Software.  It was originally written for secnet.
6  *
7  * Copyright 2013 Ian Jackson
8  * Copyright 2013 Mark Wooding
9  *
10  * You may redistribute secnet as a whole and/or modify it under the
11  * terms of the GNU General Public License as published by the Free
12  * Software Foundation; either version 3, or (at your option) any
13  * later version.
14  *
15  * You may redistribute this file and/or modify it under the terms of
16  * the GNU General Public License as published by the Free Software
17  * Foundation; either version 2, or (at your option) any later
18  * version.
19  *
20  * This software is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23  * GNU General Public License for more details.
24  *
25  * You should have received a copy of the GNU General Public License
26  * along with this software; if not, see
27  * https://www.gnu.org/licenses/gpl.html.
28  */
29
30 /*
31  * usages:
32  *   ./eax-foo-test <eax-foo-test.vectors
33  *      runs the test vectors, regenerates the file on stdout
34  *   grep -v CIPHER <eax-foo-test.vectors | ./eax-foo-test
35  *      generates output with CIPHER lines reinserted
36  * All errors result in calls to abort().
37  */
38
39 #include "eax-test.h"
40
41 struct valbuf {
42     _Bool got;
43     uint8_t v[1024];
44     size_t len;
45 };
46 #define V(vb) ((vb).v), ((vb).len)
47
48 static struct valbuf msg, key, nonce, header, cipher, ourcipher, returnplain;
49 static size_t tau;
50
51 static void trydecrypt(_Bool expected)
52 {
53     _Bool actual = eax_decrypt(-1, V(nonce), V(header), V(ourcipher), tau,
54                                returnplain.v);
55     assert(actual == expected);
56     if (actual) {
57         returnplain.len = ourcipher.len - tau;
58         assert(returnplain.len == msg.len);
59         assert(!memcmp(returnplain.v, msg.v, msg.len));
60     }
61 }
62
63 static void negtest(struct valbuf *perturb)
64 {
65     unsigned delta = 0x04;
66     size_t i;
67     for (i=0; i<perturb->len; i++) {
68         perturb->v[i] ^= delta;
69         trydecrypt(0);
70         perturb->v[i] ^= delta;
71     }
72 }
73
74 static void something(void)
75 {
76     if (!msg.got) return;
77     assert(key.got);
78     assert(nonce.got);
79     assert(header.got);
80     eaxtest_blockcipher_key_setup(V(key));
81     eax_setup(-1);
82     if (cipher.got) {
83         assert(cipher.len > msg.len);
84         tau = cipher.len - msg.len;
85         assert(tau <= blocksize);
86     } else {
87         assert(msg.len + blocksize < sizeof(ourcipher.v));
88         tau = blocksize;
89     }
90     ourcipher.len = msg.len + tau;
91     eax_encrypt(-1, V(nonce), V(header), V(msg), tau, ourcipher.v);
92     if (cipher.got) {
93         assert(ourcipher.len == cipher.len);
94         assert(!memcmp(ourcipher.v, cipher.v, cipher.len));
95         trydecrypt(1);
96         negtest(&ourcipher);
97         negtest(&header);
98     } else {
99         size_t i;
100         printf("CIPHER: ");
101         for (i=0; i<ourcipher.len; i++)
102             printf("%02X", ourcipher.v[i]);
103         putchar('\n');
104     }
105     msg.got=key.got=nonce.got=header.got=0;
106 }
107
108 static int getputchar(void)
109 {
110     int c = getchar();
111     assert(c != EOF);
112     putchar(c);
113     return c;
114 }
115
116 int main(int argc, const char *const *argv)
117 {
118     struct valbuf *cv;
119
120     assert(argc==1);
121
122     for (;;) {
123         int c = getchar();
124         switch (c) {
125         case 'M':  something();  cv = &msg;     putchar(c);  break;
126         case 'K':                cv = &key;     putchar(c);  break;
127         case 'N':                cv = &nonce;   putchar(c);  break;
128         case 'H':                cv = &header;  putchar(c);  break;
129         case 'C':                cv = &cipher;  putchar(c);  break;
130         case '\n':                              putchar(c);  continue;
131         case EOF:  something();  exit(0);
132         default:   assert(!"unexpected input");
133         }
134         cv->got = 1;
135         cv->len = 0;
136         for (;;) {
137             c = getputchar();
138             if (c == ':') break;
139             assert(isalpha(c));
140         }
141         for (;;) {
142             char hbuf[3], *ep;
143             c = getputchar();
144             if (c == '\n') break;
145             if (isspace(c)) continue;
146             assert(isprint(c));
147             hbuf[0] = c;
148             c = getputchar();
149             assert(isprint(c));
150             hbuf[1] = c;
151             hbuf[2] = 0;
152             assert(cv->len < sizeof(cv->v));
153             cv->v[cv->len++] = strtoul(hbuf,&ep,16);
154             assert(!*ep);
155         }
156     }
157     assert(!ferror(stdin));
158     assert(feof(stdin));
159     assert(!ferror(stdout));
160     assert(!fflush(stdout));
161     return 0;
162 }