projects / openssl.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
ec/asm/ecp_nistz256-x86_64.pl: add CFI directives.
[openssl.git] / test / wpackettest.c
diff --git a/test/wpackettest.c b/test/wpackettest.c
index ca2a1a79c979737924d3dc10a323312cb59c6d1f..3ab293e0e98c8d43cc7bade97921c9d894d685cf 100644 (file)
--- a/test/wpackettest.c
+++ b/test/wpackettest.c
@@ -11,6 +11,7 @@
 #include <openssl/buffer.h>
 #include "../ssl/packet_locl.h"
 #include "testutil.h"
+#include "test_main_custom.h"
 
 const static unsigned char simple1 = 0xff;
 const static unsigned char simple2[] = { 0x01, 0xff };
@@ -20,6 +21,7 @@ const static unsigned char seqsub[] = { 0x01, 0xff, 0x01, 0xff };
 const static unsigned char empty = 0x00;
 const static unsigned char alloc[] = { 0x02, 0xfe, 0xff };
 const static unsigned char submem[] = { 0x03, 0x02, 0xfe, 0xff };
+const static unsigned char fixed[] = { 0xff, 0xff, 0xff };
 
 static BUF_MEM *buf;
 
@@ -34,9 +36,10 @@ static int test_WPACKET_init(void)
     WPACKET pkt;
     int i;
     size_t written;
+    unsigned char sbuf[3];
 
-    if (       !WPACKET_init(&pkt, buf)
-            || !WPACKET_put_bytes(&pkt, 0xff, 1)
+    if (!WPACKET_init(&pkt, buf)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
                 /* Closing a top level WPACKET should fail */
             ||  WPACKET_close(&pkt)
                 /* Finishing a top level WPACKET should succeed */
@@ -55,8 +58,8 @@ static int test_WPACKET_init(void)
     }
 
     /* Now try with a one byte length prefix */
-    if (       !WPACKET_init_len(&pkt, buf, 1)
-            || !WPACKET_put_bytes(&pkt, 0xff, 1)
+    if (!WPACKET_init_len(&pkt, buf, 1)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
             || !WPACKET_finish(&pkt)
             || !WPACKET_get_total_written(&pkt, &written)
             ||  written != sizeof(simple2)
@@ -66,8 +69,8 @@ static int test_WPACKET_init(void)
     }
 
     /* And a longer length prefix */
-    if (       !WPACKET_init_len(&pkt, buf, 4)
-            || !WPACKET_put_bytes(&pkt, 0xff, 1)
+    if (!WPACKET_init_len(&pkt, buf, 4)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
             || !WPACKET_finish(&pkt)
             || !WPACKET_get_total_written(&pkt, &written)
             ||  written != sizeof(simple3)
@@ -85,7 +88,7 @@ static int test_WPACKET_init(void)
          * Putting more bytes in than fit for the size of the length prefix
          * should fail
          */
-        if ((!WPACKET_put_bytes(&pkt, 0xff, 1)) == (i != 256)) {
+        if ((!WPACKET_put_bytes_u8(&pkt, 0xff)) == (i != 256)) {
             testfail("test_WPACKET_init():4 failed\n", &pkt);
             return 0;
         }
@@ -95,6 +98,31 @@ static int test_WPACKET_init(void)
         return 0;
     }
 
+    /* Test initialising from a fixed size buffer */
+    if (!WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 0)
+                /* Adding 3 bytes should succeed */
+            || !WPACKET_put_bytes_u24(&pkt, 0xffffff)
+                /* Adding 1 more byte should fail */
+            ||  WPACKET_put_bytes_u8(&pkt, 0xff)
+                /* Finishing the top level WPACKET should succeed */
+            || !WPACKET_finish(&pkt)
+            || !WPACKET_get_total_written(&pkt, &written)
+            ||  written != sizeof(fixed)
+            || memcmp(sbuf, fixed, sizeof(sbuf)) != 0
+                /* Initialise with 1 len byte */
+            || !WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 1)
+                /* Adding 2 bytes should succeed */
+            || !WPACKET_put_bytes_u16(&pkt, 0xfeff)
+                /* Adding 1 more byte should fail */
+            ||  WPACKET_put_bytes_u8(&pkt, 0xff)
+            || !WPACKET_finish(&pkt)
+            || !WPACKET_get_total_written(&pkt, &written)
+            ||  written != sizeof(alloc)
+            ||  memcmp(sbuf, alloc, written) != 0) {
+        testfail("test_WPACKET_init():5 failed\n", &pkt);
+        return 0;
+    }
+
     return 1;
 }
 
@@ -103,7 +131,7 @@ static int test_WPACKET_set_max_size(void)
     WPACKET pkt;
     size_t written;
 
-    if (       !WPACKET_init(&pkt, buf)
+    if (!WPACKET_init(&pkt, buf)
                 /*
                  * No previous lenbytes set so we should be ok to set the max
                  * possible max size
@@ -115,10 +143,10 @@ static int test_WPACKET_set_max_size(void)
             || !WPACKET_set_max_size(&pkt, SIZE_MAX)
             || !WPACKET_finish(&pkt)) {
         testfail("test_WPACKET_set_max_size():1 failed\n", &pkt);
-        return 0; 
+        return 0;
     }
 
-    if (       !WPACKET_init_len(&pkt, buf, 1)
+    if (!WPACKET_init_len(&pkt, buf, 1)
                 /*
                  * Should fail because we already consumed 1 byte with the
                  * length
@@ -136,13 +164,13 @@ static int test_WPACKET_set_max_size(void)
                 /*
                  * Should fail because packet is already filled
                  */
-            ||  WPACKET_put_bytes(&pkt, 0xff, 1)
+            ||  WPACKET_put_bytes_u8(&pkt, 0xff)
                 /*
                  * You can't put in more bytes than max size
                  */
             || !WPACKET_set_max_size(&pkt, 0x02)
-            || !WPACKET_put_bytes(&pkt, 0xff, 1)
-            ||  WPACKET_put_bytes(&pkt, 0xff, 1)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
+            ||  WPACKET_put_bytes_u8(&pkt, 0xff)
             || !WPACKET_finish(&pkt)
             || !WPACKET_get_total_written(&pkt, &written)
             ||  written != sizeof(simple2)
@@ -160,9 +188,9 @@ static int test_WPACKET_start_sub_packet(void)
     size_t written;
     size_t len;
 
-    if (       !WPACKET_init(&pkt, buf)
+    if (!WPACKET_init(&pkt, buf)
             || !WPACKET_start_sub_packet(&pkt)
-            || !WPACKET_put_bytes(&pkt, 0xff, 1)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
                 /* Can't finish because we have a sub packet */
             ||  WPACKET_finish(&pkt)
             || !WPACKET_close(&pkt)
@@ -178,9 +206,9 @@ static int test_WPACKET_start_sub_packet(void)
     }
 
    /* Single sub-packet with length prefix */
-    if (       !WPACKET_init(&pkt, buf)
-            || !WPACKET_start_sub_packet_len(&pkt, 1)
-            || !WPACKET_put_bytes(&pkt, 0xff, 1)
+    if (!WPACKET_init(&pkt, buf)
+            || !WPACKET_start_sub_packet_u8(&pkt)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
             || !WPACKET_close(&pkt)
             || !WPACKET_finish(&pkt)
             || !WPACKET_get_total_written(&pkt, &written)
@@ -191,11 +219,11 @@ static int test_WPACKET_start_sub_packet(void)
     }
 
     /* Nested sub-packets with length prefixes */
-    if (       !WPACKET_init(&pkt, buf)
-            || !WPACKET_start_sub_packet_len(&pkt, 1)
-            || !WPACKET_put_bytes(&pkt, 0xff, 1)
-            || !WPACKET_start_sub_packet_len(&pkt, 1)
-            || !WPACKET_put_bytes(&pkt, 0xff, 1)
+    if (!WPACKET_init(&pkt, buf)
+            || !WPACKET_start_sub_packet_u8(&pkt)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
+            || !WPACKET_start_sub_packet_u8(&pkt)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
             || !WPACKET_get_length(&pkt, &len)
             || len != 1
             || !WPACKET_close(&pkt)
@@ -211,12 +239,12 @@ static int test_WPACKET_start_sub_packet(void)
     }
 
     /* Sequential sub-packets with length prefixes */
-    if (       !WPACKET_init(&pkt, buf)
-            || !WPACKET_start_sub_packet_len(&pkt, 1)
-            || !WPACKET_put_bytes(&pkt, 0xff, 1)
+    if (!WPACKET_init(&pkt, buf)
+            || !WPACKET_start_sub_packet_u8(&pkt)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
             || !WPACKET_close(&pkt)
-            || !WPACKET_start_sub_packet_len(&pkt, 1)
-            || !WPACKET_put_bytes(&pkt, 0xff, 1)
+            || !WPACKET_start_sub_packet_u8(&pkt)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
             || !WPACKET_close(&pkt)
             || !WPACKET_finish(&pkt)
             || !WPACKET_get_total_written(&pkt, &written)
@@ -226,6 +254,27 @@ static int test_WPACKET_start_sub_packet(void)
         return 0;
     }
 
+    /* Nested sub-packets with lengths filled before finish */
+    if (!WPACKET_init(&pkt, buf)
+            || !WPACKET_start_sub_packet_u8(&pkt)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
+            || !WPACKET_start_sub_packet_u8(&pkt)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
+            || !WPACKET_get_length(&pkt, &len)
+            || len != 1
+            || !WPACKET_close(&pkt)
+            || !WPACKET_get_length(&pkt, &len)
+            || len != 3
+            || !WPACKET_close(&pkt)
+            || !WPACKET_fill_lengths(&pkt)
+            || !WPACKET_get_total_written(&pkt, &written)
+            ||  written != sizeof(nestedsub)
+            ||  memcmp(buf->data, &nestedsub, written) != 0
+            || !WPACKET_finish(&pkt)) {
+        testfail("test_WPACKET_start_sub_packet():5 failed\n", &pkt);
+        return 0;
+    }
+
     return 1;
 }
 
@@ -236,11 +285,11 @@ static int test_WPACKET_set_flags(void)
     size_t written;
 
     /* Set packet to be non-zero length */
-    if (       !WPACKET_init(&pkt, buf)
+    if (!WPACKET_init(&pkt, buf)
             || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
                 /* Should fail because of zero length */
             ||  WPACKET_finish(&pkt)
-            || !WPACKET_put_bytes(&pkt, 0xff, 1)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
             || !WPACKET_finish(&pkt)
             || !WPACKET_get_total_written(&pkt, &written)
             ||  written != sizeof(simple1)
@@ -250,12 +299,12 @@ static int test_WPACKET_set_flags(void)
     }
 
     /* Repeat above test in a sub-packet */
-    if (       !WPACKET_init(&pkt, buf)
+    if (!WPACKET_init(&pkt, buf)
             || !WPACKET_start_sub_packet(&pkt)
             || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
                 /* Should fail because of zero length */
             ||  WPACKET_close(&pkt)
-            || !WPACKET_put_bytes(&pkt, 0xff, 1)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
             || !WPACKET_close(&pkt)
             || !WPACKET_finish(&pkt)
             || !WPACKET_get_total_written(&pkt, &written)
@@ -266,7 +315,7 @@ static int test_WPACKET_set_flags(void)
     }
 
     /* Set packet to abandon non-zero length */
-    if (       !WPACKET_init_len(&pkt, buf, 1)
+    if (!WPACKET_init_len(&pkt, buf, 1)
             || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
             || !WPACKET_finish(&pkt)
             || !WPACKET_get_total_written(&pkt, &written)
@@ -276,8 +325,8 @@ static int test_WPACKET_set_flags(void)
     }
 
     /* Repeat above test but only abandon a sub-packet */
-    if (       !WPACKET_init_len(&pkt, buf, 1)
-            || !WPACKET_start_sub_packet_len(&pkt, 1)
+    if (!WPACKET_init_len(&pkt, buf, 1)
+            || !WPACKET_start_sub_packet_u8(&pkt)
             || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
             || !WPACKET_close(&pkt)
             || !WPACKET_finish(&pkt)
@@ -289,10 +338,10 @@ static int test_WPACKET_set_flags(void)
     }
 
     /* And repeat with a non empty sub-packet */
-    if (       !WPACKET_init(&pkt, buf)
-            || !WPACKET_start_sub_packet_len(&pkt, 1)
+    if (!WPACKET_init(&pkt, buf)
+            || !WPACKET_start_sub_packet_u8(&pkt)
             || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
-            || !WPACKET_put_bytes(&pkt, 0xff, 1)
+            || !WPACKET_put_bytes_u8(&pkt, 0xff)
             || !WPACKET_close(&pkt)
             || !WPACKET_finish(&pkt)
             || !WPACKET_get_total_written(&pkt, &written)
@@ -310,14 +359,14 @@ static int test_WPACKET_allocate_bytes(void)
     size_t written;
     unsigned char *bytes;
 
-    if (       !WPACKET_init_len(&pkt, buf, 1)
+    if (!WPACKET_init_len(&pkt, buf, 1)
             || !WPACKET_allocate_bytes(&pkt, 2, &bytes)) {
         testfail("test_WPACKET_allocate_bytes():1 failed\n", &pkt);
         return 0;
     }
     bytes[0] = 0xfe;
     bytes[1] = 0xff;
-    if (       !WPACKET_finish(&pkt)
+    if (!WPACKET_finish(&pkt)
             || !WPACKET_get_total_written(&pkt, &written)
             ||  written != sizeof(alloc)
             ||  memcmp(buf->data, &alloc, written) != 0) {
@@ -325,6 +374,22 @@ static int test_WPACKET_allocate_bytes(void)
         return 0;
     }
 
+    /* Repeat with WPACKET_sub_allocate_bytes */
+    if (!WPACKET_init_len(&pkt, buf, 1)
+            || !WPACKET_sub_allocate_bytes_u8(&pkt, 2, &bytes)) {
+        testfail("test_WPACKET_allocate_bytes():3 failed\n", &pkt);
+        return 0;
+    }
+    bytes[0] = 0xfe;
+    bytes[1] = 0xff;
+    if (!WPACKET_finish(&pkt)
+            || !WPACKET_get_total_written(&pkt, &written)
+            ||  written != sizeof(submem)
+            ||  memcmp(buf->data, &submem, written) != 0) {
+        testfail("test_WPACKET_allocate_bytes():4 failed\n", &pkt);
+        return 0;
+    }
+
     return 1;
 }
 
@@ -334,7 +399,7 @@ static int test_WPACKET_memcpy(void)
     size_t written;
     const unsigned char bytes[] = { 0xfe, 0xff };
 
-    if (       !WPACKET_init_len(&pkt, buf, 1)
+    if (!WPACKET_init_len(&pkt, buf, 1)
             || !WPACKET_memcpy(&pkt, bytes, sizeof(bytes))
             || !WPACKET_finish(&pkt)
             || !WPACKET_get_total_written(&pkt, &written)
@@ -345,8 +410,8 @@ static int test_WPACKET_memcpy(void)
     }
 
     /* Repeat with WPACKET_sub_memcpy() */
-    if (       !WPACKET_init_len(&pkt, buf, 1)
-            || !WPACKET_sub_memcpy(&pkt, bytes, sizeof(bytes), 1)
+    if (!WPACKET_init_len(&pkt, buf, 1)
+            || !WPACKET_sub_memcpy_u8(&pkt, bytes, sizeof(bytes))
             || !WPACKET_finish(&pkt)
             || !WPACKET_get_total_written(&pkt, &written)
             ||  written != sizeof(submem)
@@ -358,16 +423,10 @@ static int test_WPACKET_memcpy(void)
     return 1;
 }
 
-int main(int argc, char *argv[])
+int test_main(int argc, char *argv[])
 {
-    BIO *err = NULL;
     int testresult = 0;
 
-    err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
-
-    CRYPTO_set_mem_debug(1);
-    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
-
     buf = BUF_MEM_new();
     if (buf != NULL) {
         ADD_TEST(test_WPACKET_init);
@@ -382,15 +441,5 @@ int main(int argc, char *argv[])
         BUF_MEM_free(buf);
     }
 
-#ifndef OPENSSL_NO_CRYPTO_MDEBUG
-    if (CRYPTO_mem_leaks(err) <= 0)
-        testresult = 1;
-#endif
-    BIO_free(err);
-
-    if (!testresult)
-        printf("PASS\n");
-
     return testresult;
 }
-
Unnamed repository; edit this file 'description' to name the repository.