add ASN1_INTEGER type to d2i_test
[openssl.git] / test / packettest.c
1 /*
2  * Written by Matt Caswell for the OpenSSL project.
3  */
4 /* ====================================================================
5  * Copyright (c) 2015 The OpenSSL Project.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  *
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in
16  *    the documentation and/or other materials provided with the
17  *    distribution.
18  *
19  * 3. All advertising materials mentioning features or use of this
20  *    software must display the following acknowledgment:
21  *    "This product includes software developed by the OpenSSL Project
22  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
23  *
24  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
25  *    endorse or promote products derived from this software without
26  *    prior written permission. For written permission, please contact
27  *    openssl-core@openssl.org.
28  *
29  * 5. Products derived from this software may not be called "OpenSSL"
30  *    nor may "OpenSSL" appear in their names without prior written
31  *    permission of the OpenSSL Project.
32  *
33  * 6. Redistributions of any form whatsoever must retain the following
34  *    acknowledgment:
35  *    "This product includes software developed by the OpenSSL Project
36  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
37  *
38  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
39  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
40  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
41  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
42  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
43  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
44  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
45  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
46  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
47  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
48  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
49  * OF THE POSSIBILITY OF SUCH DAMAGE.
50  * ====================================================================
51  *
52  * This product includes cryptographic software written by Eric Young
53  * (eay@cryptsoft.com).  This product includes software written by Tim
54  * Hudson (tjh@cryptsoft.com).
55  *
56  */
57
58
59 #include "../ssl/packet_locl.h"
60
61 #define BUF_LEN 255
62
63 static int test_PACKET_remaining(unsigned char buf[BUF_LEN])
64 {
65     PACKET pkt;
66
67     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
68             ||  PACKET_remaining(&pkt) != BUF_LEN
69             || !PACKET_forward(&pkt, BUF_LEN - 1)
70             ||  PACKET_remaining(&pkt) != 1
71             || !PACKET_forward(&pkt, 1)
72             ||  PACKET_remaining(&pkt) != 0) {
73         fprintf(stderr, "test_PACKET_remaining() failed\n");
74         return 0;
75     }
76
77     return 1;
78 }
79
80 static int test_PACKET_end(unsigned char buf[BUF_LEN])
81 {
82     PACKET pkt;
83
84     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
85             ||  PACKET_remaining(&pkt) != BUF_LEN
86             ||  PACKET_end(&pkt) != buf + BUF_LEN
87             || !PACKET_forward(&pkt, BUF_LEN - 1)
88             || PACKET_end(&pkt) != buf + BUF_LEN
89             || !PACKET_forward(&pkt, 1)
90             || PACKET_end(&pkt) != buf + BUF_LEN) {
91         fprintf(stderr, "test_PACKET_end() failed\n");
92         return 0;
93     }
94
95     return 1;
96 }
97
98 static int test_PACKET_get_1(unsigned char buf[BUF_LEN])
99 {
100     unsigned int i;
101     PACKET pkt;
102
103     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
104             || !PACKET_get_1(&pkt, &i)
105             ||  i != 0x02
106             || !PACKET_forward(&pkt, BUF_LEN - 2)
107             || !PACKET_get_1(&pkt, &i)
108             ||  i != 0xfe
109             ||  PACKET_get_1(&pkt, &i)) {
110         fprintf(stderr, "test_PACKET_get_1() failed\n");
111         return 0;
112     }
113
114     return 1;
115 }
116
117 static int test_PACKET_get_4(unsigned char buf[BUF_LEN])
118 {
119     unsigned long i;
120     PACKET pkt;
121
122     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
123             || !PACKET_get_4(&pkt, &i)
124             ||  i != 0x08060402UL
125             || !PACKET_forward(&pkt, BUF_LEN - 8)
126             || !PACKET_get_4(&pkt, &i)
127             ||  i != 0xfefcfaf8UL
128             ||  PACKET_get_4(&pkt, &i)) {
129         fprintf(stderr, "test_PACKET_get_4() failed\n");
130         return 0;
131     }
132
133     return 1;
134 }
135
136 static int test_PACKET_get_net_2(unsigned char buf[BUF_LEN])
137 {
138     unsigned int i;
139     PACKET pkt;
140
141     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
142             || !PACKET_get_net_2(&pkt, &i)
143             ||  i != 0x0204
144             || !PACKET_forward(&pkt, BUF_LEN - 4)
145             || !PACKET_get_net_2(&pkt, &i)
146             ||  i != 0xfcfe
147             ||  PACKET_get_net_2(&pkt, &i)) {
148         fprintf(stderr, "test_PACKET_get_net_2() failed\n");
149         return 0;
150     }
151
152     return 1;
153 }
154
155 static int test_PACKET_get_net_3(unsigned char buf[BUF_LEN])
156 {
157     unsigned long i;
158     PACKET pkt;
159
160     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
161             || !PACKET_get_net_3(&pkt, &i)
162             ||  i != 0x020406UL
163             || !PACKET_forward(&pkt, BUF_LEN - 6)
164             || !PACKET_get_net_3(&pkt, &i)
165             ||  i != 0xfafcfeUL
166             ||  PACKET_get_net_3(&pkt, &i)) {
167         fprintf(stderr, "test_PACKET_get_net_3() failed\n");
168         return 0;
169     }
170
171     return 1;
172 }
173
174 static int test_PACKET_get_net_4(unsigned char buf[BUF_LEN])
175 {
176     unsigned long i;
177     PACKET pkt;
178
179     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
180             || !PACKET_get_net_4(&pkt, &i)
181             ||  i != 0x02040608UL
182             || !PACKET_forward(&pkt, BUF_LEN - 8)
183             || !PACKET_get_net_4(&pkt, &i)
184             ||  i != 0xf8fafcfeUL
185             ||  PACKET_get_net_4(&pkt, &i)) {
186         fprintf(stderr, "test_PACKET_get_net_4() failed\n");
187         return 0;
188     }
189
190     return 1;
191 }
192
193 static int test_PACKET_get_sub_packet(unsigned char buf[BUF_LEN])
194 {
195     PACKET pkt, subpkt;
196     unsigned long i;
197
198     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
199             || !PACKET_get_sub_packet(&pkt, &subpkt, 4)
200             || !PACKET_get_net_4(&subpkt, &i)
201             ||  i != 0x02040608UL
202             ||  PACKET_remaining(&subpkt)
203             || !PACKET_forward(&pkt, BUF_LEN - 8)
204             || !PACKET_get_sub_packet(&pkt, &subpkt, 4)
205             || !PACKET_get_net_4(&subpkt, &i)
206             ||  i != 0xf8fafcfeUL
207             ||  PACKET_remaining(&subpkt)
208             ||  PACKET_get_sub_packet(&pkt, &subpkt, 4)) {
209         fprintf(stderr, "test_PACKET_get_sub_packet() failed\n");
210         return 0;
211     }
212
213     return 1;
214 }
215
216 static int test_PACKET_get_bytes(unsigned char buf[BUF_LEN])
217 {
218     const unsigned char *bytes;
219     PACKET pkt;
220
221     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
222             || !PACKET_get_bytes(&pkt, &bytes, 4)
223             ||  bytes[0] != 2 || bytes[1] != 4
224             ||  bytes[2] != 6 || bytes[3] != 8
225             ||  PACKET_remaining(&pkt) != BUF_LEN -4
226             || !PACKET_forward(&pkt, BUF_LEN - 8)
227             || !PACKET_get_bytes(&pkt, &bytes, 4)
228             ||  bytes[0] != 0xf8 || bytes[1] != 0xfa
229             ||  bytes[2] != 0xfc || bytes[3] != 0xfe
230             ||  PACKET_remaining(&pkt)) {
231         fprintf(stderr, "test_PACKET_get_bytes() failed\n");
232         return 0;
233     }
234
235     return 1;
236 }
237
238 static int test_PACKET_copy_bytes(unsigned char buf[BUF_LEN])
239 {
240     unsigned char bytes[4];
241     PACKET pkt;
242
243     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
244             || !PACKET_copy_bytes(&pkt, bytes, 4)
245             ||  bytes[0] != 2 || bytes[1] != 4
246             ||  bytes[2] != 6 || bytes[3] != 8
247             ||  PACKET_remaining(&pkt) != BUF_LEN - 4
248             || !PACKET_forward(&pkt, BUF_LEN - 8)
249             || !PACKET_copy_bytes(&pkt, bytes, 4)
250             ||  bytes[0] != 0xf8 || bytes[1] != 0xfa
251             ||  bytes[2] != 0xfc || bytes[3] != 0xfe
252             ||  PACKET_remaining(&pkt)) {
253         fprintf(stderr, "test_PACKET_copy_bytes() failed\n");
254         return 0;
255     }
256
257     return 1;
258 }
259
260 static int test_PACKET_copy_all(unsigned char buf[BUF_LEN])
261 {
262     unsigned char tmp[BUF_LEN];
263     PACKET pkt;
264     size_t len;
265
266     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
267                || !PACKET_copy_all(&pkt, tmp, BUF_LEN, &len)
268                || len != BUF_LEN
269                || memcmp(buf, tmp, BUF_LEN) != 0
270                || PACKET_remaining(&pkt) != BUF_LEN
271                || PACKET_copy_all(&pkt, tmp, BUF_LEN - 1, &len)) {
272         fprintf(stderr, "test_PACKET_copy_bytes() failed\n");
273         return 0;
274     }
275
276     return 1;
277 }
278
279 static int test_PACKET_memdup(unsigned char buf[BUF_LEN])
280 {
281     unsigned char *data = NULL;
282     size_t len;
283     PACKET pkt;
284
285     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
286             || !PACKET_memdup(&pkt, &data, &len)
287             ||  len != BUF_LEN
288             ||  memcmp(data, PACKET_data(&pkt), len)
289             || !PACKET_forward(&pkt, 10)
290             || !PACKET_memdup(&pkt, &data, &len)
291             ||  len != BUF_LEN - 10
292             ||  memcmp(data, PACKET_data(&pkt), len)) {
293         fprintf(stderr, "test_PACKET_memdup() failed\n");
294         OPENSSL_free(data);
295         return 0;
296     }
297
298     OPENSSL_free(data);
299     return 1;
300 }
301
302 static int test_PACKET_strndup()
303 {
304     char buf[10], buf2[10];
305     char *data = NULL;
306     PACKET pkt;
307
308     memset(buf, 'x', 10);
309     memset(buf2, 'y', 10);
310     buf2[5] = '\0';
311
312     if (       !PACKET_buf_init(&pkt, (unsigned char*)buf, 10)
313             || !PACKET_strndup(&pkt, &data)
314             ||  strlen(data) != 10
315             ||  strncmp(data, buf, 10)
316             || !PACKET_buf_init(&pkt, (unsigned char*)buf2, 10)
317             || !PACKET_strndup(&pkt, &data)
318             ||  strlen(data) != 5
319             ||  strcmp(data, buf2)) {
320         fprintf(stderr, "test_PACKET_strndup failed\n");
321         OPENSSL_free(data);
322         return 0;
323     }
324
325     OPENSSL_free(data);
326     return 1;
327 }
328
329 static int test_PACKET_contains_zero_byte()
330 {
331     char buf[10], buf2[10];
332     PACKET pkt;
333
334     memset(buf, 'x', 10);
335     memset(buf2, 'y', 10);
336     buf2[5] = '\0';
337
338     if (       !PACKET_buf_init(&pkt, (unsigned char*)buf, 10)
339             ||  PACKET_contains_zero_byte(&pkt)
340             || !PACKET_buf_init(&pkt, (unsigned char*)buf2, 10)
341             || !PACKET_contains_zero_byte(&pkt)) {
342         fprintf(stderr, "test_PACKET_contains_zero_byte failed\n");
343         return 0;
344     }
345
346     return 1;
347 }
348
349 static int test_PACKET_forward(unsigned char buf[BUF_LEN])
350 {
351     const unsigned char *byte;
352     PACKET pkt;
353
354     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
355             || !PACKET_forward(&pkt, 1)
356             || !PACKET_get_bytes(&pkt, &byte, 1)
357             ||  byte[0] != 4
358             || !PACKET_forward(&pkt, BUF_LEN - 3)
359             || !PACKET_get_bytes(&pkt, &byte, 1)
360             ||  byte[0] != 0xfe) {
361         fprintf(stderr, "test_PACKET_forward() failed\n");
362         return 0;
363     }
364
365     return 1;
366 }
367
368 static int test_PACKET_buf_init()
369 {
370     unsigned char buf[BUF_LEN];
371     PACKET pkt;
372
373     /* Also tests PACKET_remaining() */
374     if (       !PACKET_buf_init(&pkt, buf, 4)
375             ||  PACKET_remaining(&pkt) != 4
376             || !PACKET_buf_init(&pkt, buf, BUF_LEN)
377             ||  PACKET_remaining(&pkt) != BUF_LEN
378             ||  PACKET_buf_init(&pkt, buf, -1)) {
379         fprintf(stderr, "test_PACKET_buf_init() failed\n");
380         return 0;
381         }
382
383     return 1;
384 }
385
386 static int test_PACKET_null_init()
387 {
388     PACKET pkt;
389
390     PACKET_null_init(&pkt);
391     if (       PACKET_remaining(&pkt) != 0
392             || PACKET_forward(&pkt, 1)) {
393         fprintf(stderr, "test_PACKET_null_init() failed\n");
394         return 0;
395         }
396
397     return 1;
398 }
399
400 static int test_PACKET_equal(unsigned char buf[BUF_LEN])
401 {
402     PACKET pkt;
403
404     if (       !PACKET_buf_init(&pkt, buf, 4)
405             || !PACKET_equal(&pkt, buf, 4)
406             ||  PACKET_equal(&pkt, buf + 1, 4)
407             || !PACKET_buf_init(&pkt, buf, BUF_LEN)
408             || !PACKET_equal(&pkt, buf, BUF_LEN)
409             ||  PACKET_equal(&pkt, buf, BUF_LEN - 1)
410             ||  PACKET_equal(&pkt, buf, BUF_LEN + 1)
411             ||  PACKET_equal(&pkt, buf, 0)) {
412         fprintf(stderr, "test_PACKET_equal() failed\n");
413         return 0;
414         }
415
416     return 1;
417 }
418
419 static int test_PACKET_get_length_prefixed_1()
420 {
421     unsigned char buf[BUF_LEN];
422     const size_t len = 16;
423     unsigned int i;
424     PACKET pkt, short_pkt, subpkt;
425
426     buf[0] = len;
427     for (i = 1; i < BUF_LEN; i++) {
428         buf[i] = (i * 2) & 0xff;
429     }
430
431     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
432             || !PACKET_buf_init(&short_pkt, buf, len)
433             || !PACKET_get_length_prefixed_1(&pkt, &subpkt)
434             ||  PACKET_remaining(&subpkt) != len
435             || !PACKET_get_net_2(&subpkt, &i)
436             ||  i != 0x0204
437             ||  PACKET_get_length_prefixed_1(&short_pkt, &subpkt)
438             ||  PACKET_remaining(&short_pkt) != len) {
439         fprintf(stderr, "test_PACKET_get_length_prefixed_1() failed\n");
440         return 0;
441     }
442
443     return 1;
444 }
445
446 static int test_PACKET_get_length_prefixed_2()
447 {
448     unsigned char buf[1024];
449     const size_t len = 516;  /* 0x0204 */
450     unsigned int i;
451     PACKET pkt, short_pkt, subpkt;
452
453     for (i = 1; i <= 1024; i++) {
454         buf[i-1] = (i * 2) & 0xff;
455     }
456
457     if (       !PACKET_buf_init(&pkt, buf, 1024)
458             || !PACKET_buf_init(&short_pkt, buf, len)
459             || !PACKET_get_length_prefixed_2(&pkt, &subpkt)
460             ||  PACKET_remaining(&subpkt) != len
461             || !PACKET_get_net_2(&subpkt, &i)
462             ||  i != 0x0608
463             ||  PACKET_get_length_prefixed_2(&short_pkt, &subpkt)
464             ||  PACKET_remaining(&short_pkt) != len) {
465         fprintf(stderr, "test_PACKET_get_length_prefixed_2() failed\n");
466         return 0;
467     }
468
469     return 1;
470 }
471
472 static int test_PACKET_get_length_prefixed_3()
473 {
474     unsigned char buf[1024];
475     const size_t len = 516;  /* 0x000204 */
476     unsigned int i;
477     PACKET pkt, short_pkt, subpkt;
478
479     for (i = 0; i < 1024; i++) {
480         buf[i] = (i * 2) & 0xff;
481     }
482
483     if (       !PACKET_buf_init(&pkt, buf, 1024)
484             || !PACKET_buf_init(&short_pkt, buf, len)
485             || !PACKET_get_length_prefixed_3(&pkt, &subpkt)
486             ||  PACKET_remaining(&subpkt) != len
487             || !PACKET_get_net_2(&subpkt, &i)
488             ||  i != 0x0608
489             ||  PACKET_get_length_prefixed_3(&short_pkt, &subpkt)
490             ||  PACKET_remaining(&short_pkt) != len) {
491         fprintf(stderr, "test_PACKET_get_length_prefixed_3() failed\n");
492         return 0;
493     }
494
495     return 1;
496 }
497
498 static int test_PACKET_as_length_prefixed_1()
499 {
500     unsigned char buf[BUF_LEN];
501     const size_t len = 16;
502     unsigned int i;
503     PACKET pkt, exact_pkt, subpkt;
504
505     buf[0] = len;
506     for (i = 1; i < BUF_LEN; i++) {
507         buf[i] = (i * 2) & 0xff;
508     }
509
510     if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
511             || !PACKET_buf_init(&exact_pkt, buf, len + 1)
512             ||  PACKET_as_length_prefixed_1(&pkt, &subpkt)
513             ||  PACKET_remaining(&pkt) != BUF_LEN
514             || !PACKET_as_length_prefixed_1(&exact_pkt, &subpkt)
515             ||  PACKET_remaining(&exact_pkt) != 0
516             ||  PACKET_remaining(&subpkt) != len) {
517         fprintf(stderr, "test_PACKET_as_length_prefixed_1() failed\n");
518         return 0;
519     }
520
521     return 1;
522 }
523
524 static int test_PACKET_as_length_prefixed_2()
525 {
526     unsigned char buf[1024];
527     const size_t len = 516;  /* 0x0204 */
528     unsigned int i;
529     PACKET pkt, exact_pkt, subpkt;
530
531     for (i = 1; i <= 1024; i++) {
532         buf[i-1] = (i * 2) & 0xff;
533     }
534
535     if (       !PACKET_buf_init(&pkt, buf, 1024)
536             || !PACKET_buf_init(&exact_pkt, buf, len + 2)
537             ||  PACKET_as_length_prefixed_2(&pkt, &subpkt)
538             ||  PACKET_remaining(&pkt) != 1024
539             || !PACKET_as_length_prefixed_2(&exact_pkt, &subpkt)
540             ||  PACKET_remaining(&exact_pkt) != 0
541             ||  PACKET_remaining(&subpkt) != len) {
542         fprintf(stderr, "test_PACKET_as_length_prefixed_2() failed\n");
543         return 0;
544     }
545
546     return 1;
547 }
548
549 int main(int argc, char **argv)
550 {
551     unsigned char buf[BUF_LEN];
552     unsigned int i;
553
554     for (i=1; i<=BUF_LEN; i++) {
555         buf[i-1] = (i * 2) & 0xff;
556     }
557     i = 0;
558
559     if (       !test_PACKET_buf_init()
560             || !test_PACKET_null_init()
561             || !test_PACKET_remaining(buf)
562             || !test_PACKET_end(buf)
563             || !test_PACKET_equal(buf)
564             || !test_PACKET_get_1(buf)
565             || !test_PACKET_get_4(buf)
566             || !test_PACKET_get_net_2(buf)
567             || !test_PACKET_get_net_3(buf)
568             || !test_PACKET_get_net_4(buf)
569             || !test_PACKET_get_sub_packet(buf)
570             || !test_PACKET_get_bytes(buf)
571             || !test_PACKET_copy_bytes(buf)
572             || !test_PACKET_copy_all(buf)
573             || !test_PACKET_memdup(buf)
574             || !test_PACKET_strndup()
575             || !test_PACKET_contains_zero_byte()
576             || !test_PACKET_forward(buf)
577             || !test_PACKET_get_length_prefixed_1()
578             || !test_PACKET_get_length_prefixed_2()
579             || !test_PACKET_get_length_prefixed_3()
580             || !test_PACKET_as_length_prefixed_1()
581             || !test_PACKET_as_length_prefixed_2()) {
582         return 1;
583     }
584     printf("PASS\n");
585     return 0;
586 }