chiark / gitweb /
Mobile sites: Update test example
[secnet.git] / transform.c
1 /* Transform module - bulk data transformation */
2
3 /* For now it's hard-coded to do sequence
4    number/pkcs5/serpent-cbcmac/serpent with a 256 bit key for each
5    instance of serpent. We also require key material for the IVs for
6    cbcmac and cbc. Hack: we're not using full 128-bit IVs, we're just
7    using 32 bits and encrypting to get the full IV to save space in
8    the packets sent over the wire. */
9
10 #include <stdio.h>
11 #include <string.h>
12 #include "secnet.h"
13 #include "util.h"
14 #include "serpent.h"
15 #include "unaligned.h"
16
17 /* Required key length in bytes */
18 #define REQUIRED_KEYLEN ((512+64+32)/8)
19
20 struct transform {
21     closure_t cl;
22     struct transform_if ops;
23     uint32_t max_seq_skew;
24 };
25
26 struct transform_inst {
27     struct transform_inst_if ops;
28     struct keyInstance cryptkey;
29     struct keyInstance mackey;
30     uint32_t cryptiv;
31     uint32_t maciv;
32     uint32_t sendseq;
33     uint32_t lastrecvseq;
34     uint32_t max_skew;
35     bool_t keyed;
36 };
37
38 #define PKCS5_MASK 15
39
40 static bool_t transform_setkey(void *sst, uint8_t *key, int32_t keylen)
41 {
42     struct transform_inst *ti=sst;
43
44     if (keylen<REQUIRED_KEYLEN) {
45         Message(M_ERR,"transform_create: insufficient key material supplied "
46                 "(need %d bytes, got %d)\n",REQUIRED_KEYLEN,keylen);
47         return False;
48     }
49
50 #if 0
51     {
52         int i;
53         printf("Setting key to: ");
54         for (i=0; i<keylen; i++)
55             printf("%02x",key[i]);
56         printf("\n");
57     }
58 #endif /* 0 */
59
60     serpent_makekey(&ti->cryptkey,256,key);
61     serpent_makekey(&ti->mackey,256,key+32);
62     ti->cryptiv=GET_32BIT_MSB_FIRST(key+64);
63     ti->maciv=GET_32BIT_MSB_FIRST(key+68);
64     ti->sendseq=GET_32BIT_MSB_FIRST(key+72);
65     ti->lastrecvseq=ti->sendseq;
66     ti->keyed=True;
67
68     return True;
69 }
70
71 static void transform_delkey(void *sst)
72 {
73     struct transform_inst *ti=sst;
74
75     FILLZERO(ti->cryptkey);
76     FILLZERO(ti->mackey);
77     ti->keyed=False;
78 }
79
80 static uint32_t transform_forward(void *sst, struct buffer_if *buf,
81                                   const char **errmsg)
82 {
83     struct transform_inst *ti=sst;
84     uint8_t *padp;
85     int padlen;
86     uint8_t iv[16];
87     uint8_t macplain[16];
88     uint8_t macacc[16];
89     uint8_t *p, *n;
90     int i;
91
92     if (!ti->keyed) {
93         *errmsg="transform unkeyed";
94         return 1;
95     }
96
97     /* Sequence number */
98     buf_prepend_uint32(buf,ti->sendseq);
99     ti->sendseq++;
100
101     /* PKCS5, stolen from IWJ */
102                                     /* eg with blocksize=4 mask=3 mask+2=5   */
103                                     /* msgsize    20    21    22    23   24  */
104     padlen= PKCS5_MASK-buf->size;   /*           -17   -18   -19   -16  -17  */
105     padlen &= PKCS5_MASK;           /*             3     2     1     0    3  */
106     padlen++;                       /*             4     3     2     1    4  */
107
108     padp=buf_append(buf,padlen);
109     memset(padp,padlen,padlen);
110
111     /* Serpent-CBCMAC. We expand the IV from 32-bit to 128-bit using
112        one encryption. Then we do the MAC and append the result. We don't
113        bother sending the IV - it's the same each time. (If we wanted to send
114        it we've have to add 16 bytes to each message, not 4, so that the
115        message stays a multiple of 16 bytes long.) */
116     memset(iv,0,16);
117     PUT_32BIT_MSB_FIRST(iv, ti->maciv);
118     serpent_encrypt(&ti->mackey,iv,macacc);
119
120     /* CBCMAC: encrypt in CBC mode. The MAC is the last encrypted
121        block encrypted once again. */
122     for (n=buf->start; n<buf->start+buf->size; n+=16)
123     {
124         for (i = 0; i < 16; i++)
125             macplain[i] = macacc[i] ^ n[i];
126         serpent_encrypt(&ti->mackey,macplain,macacc);
127     }
128     serpent_encrypt(&ti->mackey,macacc,macacc);
129     memcpy(buf_append(buf,16),macacc,16);
130
131     /* Serpent-CBC. We expand the ID as for CBCMAC, do the encryption,
132        and prepend the IV before increasing it. */
133     memset(iv,0,16);
134     PUT_32BIT_MSB_FIRST(iv, ti->cryptiv);
135     serpent_encrypt(&ti->cryptkey,iv,iv);
136
137     /* CBC: each block is XORed with the previous encrypted block (or the IV)
138        before being encrypted. */
139     p=iv;
140
141     for (n=buf->start; n<buf->start+buf->size; n+=16)
142     {
143         for (i = 0; i < 16; i++)
144             n[i] ^= p[i];
145         serpent_encrypt(&ti->cryptkey,n,n);
146         p=n;
147     }
148
149     buf_prepend_uint32(buf,ti->cryptiv);
150     ti->cryptiv++;
151     return 0;
152 }
153
154 static uint32_t transform_reverse(void *sst, struct buffer_if *buf,
155                                   const char **errmsg)
156 {
157     struct transform_inst *ti=sst;
158     uint8_t *padp;
159     int padlen;
160     int i;
161     uint32_t seqnum, skew;
162     uint8_t iv[16];
163     uint8_t pct[16];
164     uint8_t macplain[16];
165     uint8_t macacc[16];
166     uint8_t *n;
167     uint8_t *macexpected;
168
169     if (!ti->keyed) {
170         *errmsg="transform unkeyed";
171         return 1;
172     }
173
174
175     /* CBC */
176     memset(iv,0,16);
177     {
178         uint32_t ivword = buf_unprepend_uint32(buf);
179         PUT_32BIT_MSB_FIRST(iv, ivword);
180     }
181     /* Assert bufsize is multiple of blocksize */
182     if (buf->size&0xf) {
183         *errmsg="msg not multiple of cipher blocksize";
184     }
185     serpent_encrypt(&ti->cryptkey,iv,iv);
186     for (n=buf->start; n<buf->start+buf->size; n+=16)
187     {
188         for (i = 0; i < 16; i++)
189             pct[i] = n[i];
190         serpent_decrypt(&ti->cryptkey,n,n);
191         for (i = 0; i < 16; i++)
192             n[i] ^= iv[i];
193         memcpy(iv, pct, 16);
194     }
195
196     /* CBCMAC */
197     macexpected=buf_unappend(buf,16);
198     memset(iv,0,16);
199     PUT_32BIT_MSB_FIRST(iv, ti->maciv);
200     serpent_encrypt(&ti->mackey,iv,macacc);
201
202     /* CBCMAC: encrypt in CBC mode. The MAC is the last encrypted
203        block encrypted once again. */
204     for (n=buf->start; n<buf->start+buf->size; n+=16)
205     {
206         for (i = 0; i < 16; i++)
207             macplain[i] = macacc[i] ^ n[i];
208         serpent_encrypt(&ti->mackey,macplain,macacc);
209     }
210     serpent_encrypt(&ti->mackey,macacc,macacc);
211     if (memcmp(macexpected,macacc,16)!=0) {
212         *errmsg="invalid MAC";
213         return 1;
214     }
215
216     /* PKCS5, stolen from IWJ */
217
218     padp=buf_unappend(buf,1);
219     padlen=*padp;
220     if (!padlen || (padlen > PKCS5_MASK+1)) {
221         *errmsg="pkcs5: invalid length";
222         return 1;
223     }
224
225     padp=buf_unappend(buf,padlen-1);
226     for (i=0; i<padlen-1; i++) {
227         if (*++padp != padlen) {
228             *errmsg="pkcs5: corrupted padding";
229             return 1;
230         }
231     }
232
233     /* Sequence number must be within max_skew of lastrecvseq; lastrecvseq
234        is only allowed to increase. */
235     seqnum=buf_unprepend_uint32(buf);
236     skew=seqnum-ti->lastrecvseq;
237     if (skew<0x8fffffff) {
238         /* Ok */
239         ti->lastrecvseq=seqnum;
240     } else if ((0-skew)<ti->max_skew) {
241         /* Ok */
242     } else {
243         /* Too much skew */
244         *errmsg="seqnum: too much skew";
245         return 1;
246     }
247     
248     return 0;
249 }
250
251 static void transform_destroy(void *sst)
252 {
253     struct transform_inst *st=sst;
254
255     FILLZERO(*st); /* Destroy key material */
256     free(st);
257 }
258
259 static struct transform_inst_if *transform_create(void *sst)
260 {
261     struct transform_inst *ti;
262     struct transform *st=sst;
263
264     ti=safe_malloc(sizeof(*ti),"transform_create");
265     /* mlock XXX */
266
267     ti->ops.st=ti;
268     ti->ops.setkey=transform_setkey;
269     ti->ops.delkey=transform_delkey;
270     ti->ops.forwards=transform_forward;
271     ti->ops.reverse=transform_reverse;
272     ti->ops.destroy=transform_destroy;
273     ti->max_skew=st->max_seq_skew;
274     ti->keyed=False;
275
276     return &ti->ops;
277 }
278
279 static list_t *transform_apply(closure_t *self, struct cloc loc,
280                                dict_t *context, list_t *args)
281 {
282     struct transform *st;
283     item_t *item;
284     dict_t *dict;
285
286     st=safe_malloc(sizeof(*st),"serpent");
287     st->cl.description="serpent-cbc256";
288     st->cl.type=CL_TRANSFORM;
289     st->cl.apply=NULL;
290     st->cl.interface=&st->ops;
291     st->ops.st=st;
292     st->ops.max_start_pad=28; /* 4byte seqnum, 16byte pad, 4byte MACIV,
293                                  4byte IV */
294     st->ops.max_end_pad=16; /* 16byte CBCMAC */
295
296     /* We need 256*2 bits for serpent keys, 32 bits for CBC-IV and 32 bits
297        for CBCMAC-IV, and 32 bits for init sequence number */
298     st->ops.keylen=REQUIRED_KEYLEN;
299     st->ops.create=transform_create;
300
301     /* First parameter must be a dict */
302     item=list_elem(args,0);
303     if (!item || item->type!=t_dict)
304         cfgfatal(loc,"userv-ipif","parameter must be a dictionary\n");
305     
306     dict=item->data.dict;
307     st->max_seq_skew=dict_read_number(dict, "max-sequence-skew",
308                                       False, "serpent-cbc256", loc, 10);
309
310     return new_closure(&st->cl);
311 }
312
313 void transform_module(dict_t *dict)
314 {
315     struct keyInstance k;
316     uint8_t data[32];
317     uint8_t plaintext[16];
318     uint8_t ciphertext[16];
319
320     /*
321      * Serpent self-test.
322      * 
323      * This test pattern is taken directly from the Serpent test
324      * vectors, to ensure we have all endianness issues correct. -sgt
325      */
326
327     /* Serpent self-test */
328     memcpy(data,
329            "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xaa\xbb\xcc\xdd\xee\xff"
330            "\xff\xee\xdd\xcc\xbb\xaa\x99\x88\x77\x66\x55\x44\x33\x22\x11\x00",
331            32);
332     serpent_makekey(&k,256,data);
333
334     memcpy(plaintext,
335            "\x01\x23\x45\x67\x89\xab\xcd\xef\xfe\xdc\xba\x98\x76\x54\x32\x10",
336            16);
337     serpent_encrypt(&k,plaintext,ciphertext);
338
339     if (memcmp(ciphertext, "\xca\x7f\xa1\x93\xe3\xeb\x9e\x99"
340                "\xbd\x87\xe3\xaf\x3c\x9a\xdf\x93", 16)) {
341         fatal("transform_module: serpent failed self-test (encrypt)");
342     }
343     serpent_decrypt(&k,ciphertext,plaintext);
344     if (memcmp(plaintext, "\x01\x23\x45\x67\x89\xab\xcd\xef"
345                "\xfe\xdc\xba\x98\x76\x54\x32\x10", 16)) {
346         fatal("transform_module: serpent failed self-test (decrypt)");
347     }
348
349     add_closure(dict,"serpent256-cbc",transform_apply);
350
351 #ifdef TEST_WHOLE_TRANSFORM
352     {
353         struct transform *tr;
354         void *ti;
355         struct buffer_if buf;
356         const char text[] = "This is a piece of test text.";
357         char keymaterial[76] =
358             "Seventy-six bytes i"
359             "n four rows of 19; "
360             "this looks almost l"
361             "ike a poem but not.";
362         const char *errmsg;
363         int i;
364
365         tr = malloc(sizeof(struct transform));
366         tr->max_seq_skew = 20;
367         ti = transform_create(tr);
368
369         transform_setkey(ti, keymaterial, 76);
370
371         buf.base = malloc(4096);
372         buffer_init(&buf, 2048);
373         memcpy(buf_append(&buf, sizeof(text)), text, sizeof(text));
374         if (transform_forward(ti, &buf, &errmsg)) {
375             fatal("transform_forward test: %s", errmsg);
376         }
377         printf("transformed text is:\n");
378         for (i = 0; i < buf.size; i++)
379             printf("%02x%c", buf.start[i],
380                    (i%16==15 || i==buf.size-1 ? '\n' : ' '));
381         if (transform_reverse(ti, &buf, &errmsg)) {
382             fatal("transform_reverse test: %s", errmsg);
383         }
384         printf("transform reversal worked OK\n");
385     }
386 #endif
387 }