chiark / gitweb /
test: Rerun tests only when deps changed
[secnet.git] / transform-eax.c
1 /*
2  * eax-transform.c: EAX-Serpent bulk data transformation
3  */
4 /*
5  * This file is part of secnet.
6  * See README for full list of copyright holders.
7  *
8  * secnet is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  * 
13  * secnet is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  * 
18  * You should have received a copy of the GNU General Public License
19  * version 3 along with secnet; if not, see
20  * https://www.gnu.org/licenses/gpl.html.
21  */
22 /*
23  * We use EAX with the following parameters:
24  *
25  *   Plaintext:
26  *      Concatenation of:
27  *        Data packet as supplied to us
28  *        Zero or more zero bytes ignored by receiver } padding
29  *        One byte padding length                     }
30  *      This is a bit like PKCS#5.  It helps disguise message lengths.
31  *      It also provides a further room for future expansion.  When
32  *      transmitting we pad the message to the next multiple of
33  *      a configurable rounding factor, 16 bytes by default.
34  *
35  *   Transmitted message:
36  *      Concatenation of:
37  *        EAX ciphertext
38  *        32-bit sequence number (initially zero)
39  *      The sequence number allows us to discard far-too-old
40  *      packets.
41  *
42  *   Nonce:
43  *      Concatenation of:
44  *        32-bit sequence number (big endian)
45  *               initial value comes from SHA-512 hash (see below)
46  *        1 byte: 0x01 if sender has setup priority, 0x00 if it doesn't
47  *               (ie, the direction of data flow)
48  *
49  *   Header: None
50  *
51  *   Tag length:
52  *      16 bytes (128 bits) by default
53  *
54  *   Key:
55  *      The first 32 bytes of the SHA-512 hash of the shared secret
56  *      from the DH key exchange (the latter being expressed as
57  *      the shortest possible big-endian octet string).
58  *
59  * The bytes [32,40> of the hash of the shared secret are used for
60  * initial sequence numbers: [32,36> for those sent by the end without
61  * setup priority, [36,40> for those for the other end.
62  *
63  */
64
65 #include "secnet.h"
66 #include "unaligned.h"
67 #include "util.h"
68 #include "serpent.h"
69 #include "sha512.h"
70 #include "transform-common.h"
71 #include "hexdebug.h"
72
73 #define BLOCK_SIZE 16
74 #define SEQLEN 4
75
76 struct transform_params {
77     SEQNUM_PARAMS_FIELDS;
78     uint32_t tag_length, padding_mask;
79 };
80
81 struct transform {
82     closure_t cl;
83     struct transform_if ops;
84     struct transform_params p;
85 };
86
87 struct transform_inst {
88     struct transform_inst_if ops;
89     struct transform_params p;
90     /* remaining valid iff keyed */
91     unsigned direction:1;
92     SEQNUM_KEYED_FIELDS;
93     struct keyInstance key;
94     uint8_t info_b[BLOCK_SIZE], info_p[BLOCK_SIZE];
95 };
96
97 static void block_encrypt(struct transform_inst *transform_inst,
98                           uint8_t dst[BLOCK_SIZE],
99                           const uint8_t src[BLOCK_SIZE])
100 {
101     serpent_encrypt(&transform_inst->key, src, dst);
102 }
103
104 #define INFO                    struct transform_inst *transform_inst
105 #define I                       transform_inst
106 #define EAX_ENTRYPOINT_DECL     static
107 #define BLOCK_ENCRYPT(dst,src)  block_encrypt(transform_inst,dst,src)
108 #define INFO_B                  (transform_inst->info_b)
109 #define INFO_P                  (transform_inst->info_p)
110
111 #include "eax.c"
112
113 #if 0
114
115 #define TEAX_DEBUG(ary,sz) teax_debug(__func__,__LINE__,#ary,#sz,ary,sz)
116 static void teax_debug(const char *func, int line,
117                        const char *aryp, const char *szp,
118                        const void *ary, size_t sz)
119 {
120     fprintf(stderr,"TEAX %s:%-3d %10s %15s : ", func,line,aryp,szp);
121     hexdebug(stderr,ary,sz);
122     fprintf(stderr,"\n");
123 }
124
125 #else
126
127 #define TEAX_DEBUG(ary,sz) /* empty */
128
129 #endif
130
131 static bool_t transform_setkey(void *sst, uint8_t *key, int32_t keylen,
132                                bool_t direction)
133 {
134     struct transform_inst *ti=sst;
135     struct sha512_ctx hash_ctx;
136     uint8_t hash_out[64];
137
138     TEAX_DEBUG(key,keylen);
139
140     sha512_init_ctx(&hash_ctx);
141     sha512_process_bytes(key, keylen, &hash_ctx);
142     sha512_finish_ctx(&hash_ctx, hash_out);
143
144     TEAX_DEBUG(hash_out,32);
145     TEAX_DEBUG(hash_out+32,8);
146
147     ti->direction=direction;
148     serpent_makekey(&ti->key, 32*8, hash_out);
149     eax_setup(ti);
150     SEQNUM_KEYED_INIT(get_uint32(hash_out+32+!direction*4),
151                       get_uint32(hash_out+32+direction*4));
152
153     return True;
154 }
155
156 TRANSFORM_VALID;
157
158 TRANSFORM_DESTROY;
159
160 static void transform_delkey(void *sst)
161 {
162     struct transform_inst *ti=sst;
163
164     FILLZERO(ti->key);
165     FILLZERO(ti->info_b);
166     FILLZERO(ti->info_p);
167     ti->keyed=False;
168 }
169
170 static transform_apply_return transform_forward(void *sst,
171         struct buffer_if *buf, const char **errmsg)
172 {
173     struct transform_inst *ti=sst;
174
175     KEYED_CHECK;
176     
177     size_t padlen = ti->p.padding_mask - buf->size;
178     padlen &= ti->p.padding_mask;
179     padlen++;
180
181     uint8_t *pad = buf_append(buf,padlen);
182     memset(pad, 0, padlen-1);
183     pad[padlen-1] = padlen;
184
185     uint8_t nonce[SEQLEN+1];
186     put_uint32(nonce,ti->sendseq);
187     nonce[SEQLEN] = ti->direction;
188
189     TEAX_DEBUG(nonce,sizeof(nonce));
190     TEAX_DEBUG(buf->start,buf->size);
191
192     assert(buf_append(buf,ti->p.tag_length));
193     eax_encrypt(ti, nonce,sizeof(nonce), 0,0,
194                 buf->start,buf->size-ti->p.tag_length,
195                 ti->p.tag_length, buf->start);
196
197     TEAX_DEBUG(buf->start,buf->size);
198
199     BUF_ADD_BYTES(append,buf,nonce,SEQLEN);
200
201     TEAX_DEBUG(nonce,SEQLEN);
202
203     ti->sendseq++;
204
205     return 0;
206 }
207
208 static transform_apply_return transform_reverse(void *sst,
209         struct buffer_if *buf, const char **errmsg)
210 {
211     struct transform_inst *ti=sst;
212
213     KEYED_CHECK;
214
215     TEAX_DEBUG(buf->start,buf->size);
216
217     uint8_t nonce[SEQLEN+1];
218     const uint8_t *seqp = buf_unappend(buf,SEQLEN);
219     if (!seqp) goto too_short;
220
221     TEAX_DEBUG(seqp,SEQLEN);
222
223     uint32_t seqnum = get_uint32(seqp);
224
225     memcpy(nonce,seqp,SEQLEN);
226     nonce[4] = !ti->direction;
227
228     TEAX_DEBUG(nonce,sizeof(nonce));
229     TEAX_DEBUG(buf->start,buf->size);
230
231     bool_t ok = eax_decrypt(ti, nonce,sizeof(nonce), 0,0, buf->start,buf->size,
232                             ti->p.tag_length, buf->start);
233     if (!ok) {
234         TEAX_DEBUG(0,0);
235         *errmsg="EAX decryption failed";
236         return transform_apply_err;
237     }
238     assert(buf->size >= (int)ti->p.tag_length);
239     buf->size -= ti->p.tag_length;
240
241     TEAX_DEBUG(buf->start,buf->size);
242
243     const uint8_t *padp = buf_unappend(buf,1);
244     if (!padp) goto too_short;
245
246     TEAX_DEBUG(padp,1);
247
248     size_t padlen = *padp;
249     if (!buf_unappend(buf,padlen-1)) goto too_short;
250
251     SEQNUM_CHECK(seqnum, &ti->p);
252
253     TEAX_DEBUG(buf->start,buf->size);
254
255     return 0;
256
257  too_short:
258     *errmsg="ciphertext or plaintext too short";
259     return transform_apply_err;
260 }
261
262 static struct transform_inst_if *transform_create(void *sst)
263 {
264     struct transform *st=sst;
265
266     TRANSFORM_CREATE_CORE;
267
268     ti->p=st->p;
269
270     return &ti->ops;
271 }
272
273 static list_t *transform_apply(closure_t *self, struct cloc loc,
274                                dict_t *context, list_t *args)
275 {
276     struct transform *st;
277     item_t *item;
278     dict_t *dict;
279
280     NEW(st);
281     st->cl.description="eax-serpent";
282     st->cl.type=CL_TRANSFORM;
283     st->cl.apply=NULL;
284     st->cl.interface=&st->ops;
285     st->ops.st=st;
286
287     /* First parameter must be a dict */
288     item=list_elem(args,0);
289     if (!item || item->type!=t_dict)
290         cfgfatal(loc,"eax-serpent","parameter must be a dictionary\n");
291     dict=item->data.dict;
292
293     SET_CAPAB_BIT(CAPAB_BIT_EAXSERPENT);
294
295     SEQNUM_PARAMS_INIT(dict,&st->p,"eax-serpent",loc);
296
297     st->p.tag_length=dict_read_number(dict, "tag-length-bytes",
298                                       False, "eax-serpent", loc, 128/8);
299     if (st->p.tag_length<1 || st->p.tag_length>BLOCK_SIZE)
300         cfgfatal(loc,"eax-serpent","tag-length-bytes out of range 0..%d\n",
301                  BLOCK_SIZE);
302
303     uint32_t padding_round=dict_read_number(dict, "padding-rounding",
304                                             False, "eax-serpent", loc, 16);
305     if (padding_round & (padding_round-1))
306         cfgfatal(loc,"eax-serpent","padding-round not a power of two\n");
307     if (padding_round > 255)
308         cfgfatal(loc,"eax-serpent","padding-round must be 1..128\n");
309     if (padding_round == 0)
310         padding_round = 1;
311     st->p.padding_mask = padding_round-1;
312
313     update_max_start_pad(&transform_max_start_pad, 0);
314
315     st->ops.keylen=0;
316     st->ops.create=transform_create;
317
318     return new_closure(&st->cl);
319 }
320
321 void transform_eax_module(dict_t *dict)
322 {
323     add_closure(dict,"eax-serpent",transform_apply);
324 }