rbnacl-libsodium 1.0.11 → 1.0.13

data/vendor/libsodium/test/default/pwhash_scrypt.exp

@@ -1,7 +1,8 @@
 8d40f5f8c6a1791204f03e19a98cd74f918b6e331b39cfc2415e5014d7738b7bb0a83551fb14a035e07fdd4dc0c60c1a6822ac253918979f6324ff0c87cba75d3b91f88f41ca5414a0f152bdc4d636f42ab2250afd058c19ec31a3374d1bd7133289bf21513ff67cbf8482e626aee9864c58fd05f9ea02e508a10182b7d838157119866f072004987ef6c56683ed207705923921af9d76444a331a
 d985d4c278343a46d82af0c4268b7ae6b6d1d2dd289675ef45bfb6d0648bffe5bab8c91228f3a31b091154a9c1142670a07b92e70a298333066de07db9300e046fd7cacc99780804683df7babdfc9d019047178400b2875bde0a1ad824dda7a422d9ed48475af9a3876378dd3a2f206e34984e223afb82c0c1e4644c9a458f4666379fdd3e2d9206d87e3c32c3977f35826a27590baaa1ec1a3bd7d15a92bc84c95dcfc56c14fca7c4c9810162dfdf9dc08a191e79fe40250b7e07d3a9317d9a5cb56e1062c419a6cd6a9b73128e8ad79ab7efffbb3cc52c1f49f86d2ebb46e6e4846aecdb14c2d046f5380517ff8cc794e4a772a58b93083dad
 ee7e9e1369267ec555981f0ea088ff6f93953abfcb767d88ec3c46393d24cfbaba5e4e26e0f35b5d5259647748476d65cd8881c96f8cda049d9c877b2d33d932e67f4c0df2cb434b4b4900e0c49c3f8ba9663795420577e65d0b456201ad9162fbc485c7b44f2b34e6673aa3692c123021ee3b624c3bb22b808b89613d8ecc7b87da47f57152eb3f7b10ad206f6b09cb6935b347b5e42bc3b8c9c9bcd8d7b7c44929b367fc279dec48ea78e6ee3e2620d7459700bd0aedb1c9aa5a323ca94403927f5e5c2b73bda7c5c3287b62fe51874cfeb1dc3151cd886b26d83ece68833229d2d432798c602d85b0505947207d8430febbe901164b12ce
-1828b82997
+pwhash failure
+0000000000
 bcc5c2fd785e4781d1201ed43d84925537e2a540d3de55f5812f29e9dd0a4a00451a5c8ddbb4862c03d45c75bf91b7fb49265feb667ad5c899fdbf2ca19eac67aa5e48595d5b02f8183ab07f71b1ce0d76e5df54919f63810ad0893ded7d1ca18fc956ec06ffd4c3d1f77a00ed53608947b25eea5df6bea02272be15815f974c321a2a9208674fdf59d1d798c2a12f1889df68b0c222b37ee9ef0d6391fc160b0281ec53073cb3a3706ce1d71c3af2f5237a1b3d8545d99012eecc0b4abb
 82765c040c58c1810f8c053ef5c248556299385476bde44bdd91a0d9a239f24e9b1717fd8b23209ffa45b7aa7937296c601b79e77da99e8d2fda0ea4459be2d0900f5bc5a269b5488d873d4632d1baf75965e509ee24b12501a9ce3bbbd8b7d759987d545a1c221a363195e5802d768b3b9e00ebe5ac0ed8ad2362c1c4157b910a40f94adf2561a2b0d3e65dbb06f244e5ac44d362103df54c9b9175777b3db1cdadb03e977ab8a79baf1e1e18ec9f5d0f25c487ddc53d7e81910f83576b44e9caeece26e2eb376569ad3a8cdccbde8bc355210e
 ca9216d4127e2e4a6ee3584b49be106217bb61cc807016d46d0cfbb1fd722e2bbac33541386bdfeac41a299ead22790993fcaa8e1d23bd1c8426afa5ff4c08e731dc476ef834f142c32dfb2c1be12b9978802e63b2cd6f226b1a8df59f0c79154d7ef4296a68ec654538d987104f9a11aca1b7c83ab2ed8fd69da6b88f0bcbd27d3fea01329cecf10c57ec3ba163d57b38801bd6c3b31ce527b33717bb56a46f78fb96be9f2424a21b3284232388cbba6a74

data/vendor/libsodium/test/default/pwhash_scrypt_ll.c

@@ -2,60 +2,58 @@
 #define TEST_NAME "pwhash_scrypt_ll"
 #include "cmptest.h"
 
-/* Tarsnap test vectors, see: https://www.tarsnap.com/scrypt/scrypt.pdf */
-
-static const char *password1 = "";
-static const char *salt1 = "";
-static uint64_t N1 = 16U;
-static uint32_t r1 = 1U;
-static uint32_t p1 = 1U;
-
-static const char *password2 = "password";
-static const char *salt2 = "NaCl";
-static uint64_t N2 = 1024U;
-static uint32_t r2 = 8U;
-static uint32_t p2 = 16U;
-
-static const char *password3 = "pleaseletmein";
-static const char *salt3 = "SodiumChloride";
-static uint64_t N3 = 16384U;
-static uint32_t r3 = 8U;
-static uint32_t p3 = 1U;
-
-static void test_vector(const char *password, const char *salt, uint64_t N,
-                        uint32_t r, uint32_t p)
+static const char *   passwd1 = "";
+static const char *   salt1   = "";
+static const uint64_t N1      = 16U;
+static const uint32_t r1      = 1U;
+static const uint32_t p1      = 1U;
+
+static const char *   passwd2 = "password";
+static const char *   salt2   = "NaCl";
+static const uint64_t N2      = 1024U;
+static const uint32_t r2      = 8U;
+static const uint32_t p2      = 16U;
+
+static const char *   passwd3 = "pleaseletmein";
+static const char *   salt3   = "SodiumChloride";
+static const uint64_t N3      = 16384U;
+static const uint32_t r3      = 8U;
+static const uint32_t p3      = 1U;
+
+static void
+tv(const char *passwd, const char *salt, uint64_t N, uint32_t r, uint32_t p)
 {
     uint8_t data[64];
-    size_t i;
-    size_t olen = (sizeof data / sizeof data[0]);
-    size_t passwordLength = strlen(password);
-    size_t saltLenght = strlen(salt);
-    int lineitems = 0;
-    int lineitemsLimit = 15;
+    size_t  i;
+    size_t  olen       = (sizeof data / sizeof data[0]);
+    size_t  passwd_len = strlen(passwd);
+    size_t  salt_len   = strlen(salt);
+    int     line_items  = 0;
 
     if (crypto_pwhash_scryptsalsa208sha256_ll(
-            (const uint8_t *)password, passwordLength, (const uint8_t *)salt,
-            saltLenght, N, r, p, data, olen) != 0) {
-        printf("pwhash_scryptsalsa208sha256_ll([%s],[%s]) failure\n", password,
+            (const uint8_t *) passwd, passwd_len, (const uint8_t *) salt,
+            salt_len, N, r, p, data, olen) != 0) {
+        printf("pwhash_scryptsalsa208sha256_ll([%s],[%s]) failure\n", passwd,
                salt);
         return;
     }
 
-    printf("scrypt('%s', '%s', %lu, %lu, %lu, %lu) =\n", password, salt,
-           (unsigned long)N, (unsigned long)r, (unsigned long)p,
-           (unsigned long)olen);
+    printf("scrypt('%s', '%s', %lu, %lu, %lu, %lu) =\n", passwd, salt,
+           (unsigned long) N, (unsigned long) r, (unsigned long) p,
+           (unsigned long) olen);
 
-    for (i = 0; i < olen; ++i) {
-        printf("%02x%c", data[i], lineitems < lineitemsLimit ? ' ' : '\n');
-        lineitems = lineitems < lineitemsLimit ? lineitems + 1 : 0;
+    for (i = 0; i < olen; i++) {
+        printf("%02x%c", data[i], line_items < 15 ? ' ' : '\n');
+        line_items = line_items < 15 ? line_items + 1 : 0;
     }
 }
 
-int main(void)
+int
+main(void)
 {
-    test_vector(password1, salt1, N1, r1, p1);
-    test_vector(password2, salt2, N2, r2, p2);
-    test_vector(password3, salt3, N3, r3, p3);
+    tv(passwd1, salt1, N1, r1, p1);
+    tv(passwd2, salt2, N2, r2, p2);
+    tv(passwd3, salt3, N3, r3, p3);
 
     return 0;
 }

data/vendor/libsodium/test/default/randombytes.c

@@ -2,10 +2,11 @@
 #define TEST_NAME "randombytes"
 #include "cmptest.h"
 
-static unsigned char x[65536];
+static unsigned char      x[65536];
 static unsigned long long freq[256];
 
-static int compat_tests(void)
+static int
+compat_tests(void)
 {
     size_t i;
 
@@ -15,7 +16,7 @@ static int compat_tests(void)
         freq[i] = 0;
     }
     for (i = 0; i < sizeof x; ++i) {
-        ++freq[255 & (int)x[i]];
+        ++freq[255 & (int) x[i]];
     }
     for (i = 0; i < 256; ++i) {
         if (!freq[i]) {
@@ -25,11 +26,18 @@ static int compat_tests(void)
     return 0;
 }
 
-static int randombytes_tests(void)
+static int
+randombytes_tests(void)
 {
-    unsigned int f = 0U;
-    unsigned int i;
-    uint32_t     n;
+    static const unsigned char seed[randombytes_SEEDBYTES] = {
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
+        0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
+        0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
+    };
+    unsigned char out[100];
+    unsigned int  f = 0U;
+    unsigned int  i;
+    uint32_t      n;
 
 #ifdef __EMSCRIPTEN__
     assert(strcmp(randombytes_implementation_name(), "js") == 0);
@@ -43,8 +51,8 @@ static int randombytes_tests(void)
         n = randombytes_random();
         f |= ((n >> 24) > 1);
         f |= ((n >> 16) > 1) << 1;
-        f |= ((n >>  8) > 1) << 2;
-        f |= ((n      ) > 1) << 3;
+        f |= ((n >> 8) > 1) << 2;
+        f |= ((n) > 1) << 3;
         f |= (n > 0x7fffffff) << 4;
     } while (f != 0x1f);
     randombytes_close();
@@ -84,7 +92,7 @@ static int randombytes_tests(void)
         freq[i] = 0;
     }
     for (i = 0; i < sizeof x; ++i) {
-        ++freq[255 & (int)x[i]];
+        ++freq[255 & (int) x[i]];
     }
     for (i = 0; i < 256; ++i) {
         if (!freq[i]) {
@@ -92,20 +100,32 @@ static int randombytes_tests(void)
         }
     }
     assert(randombytes_uniform(1U) == 0U);
+
+    randombytes_buf_deterministic(out, sizeof out, seed);
+    for (i = 0; i < sizeof out; ++i) {
+        printf("%02x", out[i]);
+    }
+    printf(" (deterministic)\n");
+
     randombytes_close();
 
     randombytes(x, 1U);
     randombytes_close();
 
+    assert(randombytes_SEEDBYTES > 0);
+    assert(randombytes_seedbytes() == randombytes_SEEDBYTES);
+
     return 0;
 }
 
-static uint32_t randombytes_uniform_impl(const uint32_t upper_bound)
+static uint32_t
+randombytes_uniform_impl(const uint32_t upper_bound)
 {
     return upper_bound;
 }
 
-static int impl_tests(void)
+static int
+impl_tests(void)
 {
 #ifndef __native_client__
     randombytes_implementation impl = randombytes_sysrandom_implementation;
@@ -128,7 +148,8 @@ static int impl_tests(void)
     return 0;
 }
 
-int main(void)
+int
+main(void)
 {
     compat_tests();
     randombytes_tests();

data/vendor/libsodium/test/default/randombytes.exp

@@ -1 +1,2 @@
+0d8e6cc68715648926732e7ea73250cfaf2d58422083904c841a8ba33b986111f346ba50723a68ae283524a6bded09f83be6b80595856f72e25b86918e8b114bafb94bc8abedd73daab454576b7c5833eb0bf982a1bb4587a5c970ff0810ca3b791d7e12 (deterministic)
 OK

data/vendor/libsodium/test/default/scalarmult.c

@@ -2,32 +2,35 @@
 #define TEST_NAME "scalarmult"
 #include "cmptest.h"
 
-static const unsigned char alicesk[crypto_scalarmult_BYTES]
-    = { 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16, 0xc1,
-        0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87, 0xeb, 0xc0,
-        0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9, 0x2c, 0x2a };
+static const unsigned char alicesk[crypto_scalarmult_BYTES] = {
+    0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16, 0xc1,
+    0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87, 0xeb, 0xc0,
+    0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9, 0x2c, 0x2a
+};
 
-static const unsigned char bobsk[crypto_scalarmult_BYTES]
-    = { 0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a, 0x4b, 0x79, 0xe1, 0x7f,
-        0x8b, 0x83, 0x80, 0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26, 0x18,
-        0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27, 0xff, 0x88, 0xe0, 0xeb };
+static const unsigned char bobsk[crypto_scalarmult_BYTES] = {
+    0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a, 0x4b, 0x79, 0xe1, 0x7f,
+    0x8b, 0x83, 0x80, 0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26, 0x18,
+    0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27, 0xff, 0x88, 0xe0, 0xeb
+};
 
-static const unsigned char small_order_p[crypto_scalarmult_BYTES]
-    = { 0xe0, 0xeb, 0x7a, 0x7c, 0x3b, 0x41, 0xb8, 0xae, 0x16, 0x56, 0xe3,
-        0xfa, 0xf1, 0x9f, 0xc4, 0x6a, 0xda, 0x09, 0x8d, 0xeb, 0x9c, 0x32,
-        0xb1, 0xfd, 0x86, 0x62, 0x05, 0x16, 0x5f, 0x49, 0xb8, 0x00 };
+static const unsigned char small_order_p[crypto_scalarmult_BYTES] = {
+    0xe0, 0xeb, 0x7a, 0x7c, 0x3b, 0x41, 0xb8, 0xae, 0x16, 0x56, 0xe3,
+    0xfa, 0xf1, 0x9f, 0xc4, 0x6a, 0xda, 0x09, 0x8d, 0xeb, 0x9c, 0x32,
+    0xb1, 0xfd, 0x86, 0x62, 0x05, 0x16, 0x5f, 0x49, 0xb8, 0x00
+};
 
 static char hex[crypto_scalarmult_BYTES * 2 + 1];
 
-int main(void)
+int
+main(void)
 {
     unsigned char *alicepk =
         (unsigned char *) sodium_malloc(crypto_scalarmult_BYTES);
     unsigned char *bobpk =
         (unsigned char *) sodium_malloc(crypto_scalarmult_BYTES);
-    unsigned char *k =
-        (unsigned char *) sodium_malloc(crypto_scalarmult_BYTES);
-    int ret;
+    unsigned char *k = (unsigned char *) sodium_malloc(crypto_scalarmult_BYTES);
+    int            ret;
 
     assert(alicepk != NULL && bobpk != NULL && k != NULL);
 
@@ -62,8 +65,8 @@ int main(void)
     assert(crypto_scalarmult_scalarbytes() > 0U);
     assert(strcmp(crypto_scalarmult_primitive(), "curve25519") == 0);
     assert(crypto_scalarmult_bytes() == crypto_scalarmult_curve25519_bytes());
-    assert(crypto_scalarmult_scalarbytes()
-           == crypto_scalarmult_curve25519_scalarbytes());
+    assert(crypto_scalarmult_scalarbytes() ==
+           crypto_scalarmult_curve25519_scalarbytes());
     assert(crypto_scalarmult_bytes() == crypto_scalarmult_scalarbytes());
 
     return 0;

data/vendor/libsodium/test/default/scalarmult2.c

@@ -2,14 +2,16 @@
 #define TEST_NAME "scalarmult2"
 #include "cmptest.h"
 
-static unsigned char bobsk[32]
-    = { 0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a, 0x4b, 0x79, 0xe1, 0x7f,
-        0x8b, 0x83, 0x80, 0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26, 0x18,
-        0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27, 0xff, 0x88, 0xe0, 0xeb };
+static unsigned char bobsk[32] = { 0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a,
+                                   0x4b, 0x79, 0xe1, 0x7f, 0x8b, 0x83, 0x80,
+                                   0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26,
+                                   0x18, 0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27,
+                                   0xff, 0x88, 0xe0, 0xeb };
 
 static unsigned char bobpk[32];
 
-int main(void)
+int
+main(void)
 {
     int i;
 
@@ -21,7 +23,7 @@ int main(void)
         } else {
             printf(" ");
         }
-        printf("0x%02x", (unsigned int)bobpk[i]);
+        printf("0x%02x", (unsigned int) bobpk[i]);
         if (i % 8 == 7) {
             printf("\n");
         }

data/vendor/libsodium/test/default/scalarmult5.c

@@ -2,19 +2,22 @@
 #define TEST_NAME "scalarmult5"
 #include "cmptest.h"
 
-static unsigned char alicesk[32]
-    = { 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16, 0xc1,
-        0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87, 0xeb, 0xc0,
-        0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9, 0x2c, 0x2a };
+static unsigned char alicesk[32] = { 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5,
+                                     0x7d, 0x3c, 0x16, 0xc1, 0x72, 0x51, 0xb2,
+                                     0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87, 0xeb,
+                                     0xc0, 0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5,
+                                     0x1d, 0xb9, 0x2c, 0x2a };
 
-static unsigned char bobpk[32]
-    = { 0xde, 0x9e, 0xdb, 0x7d, 0x7b, 0x7d, 0xc1, 0xb4, 0xd3, 0x5b, 0x61,
-        0xc2, 0xec, 0xe4, 0x35, 0x37, 0x3f, 0x83, 0x43, 0xc8, 0x5b, 0x78,
-        0x67, 0x4d, 0xad, 0xfc, 0x7e, 0x14, 0x6f, 0x88, 0x2b, 0x4f };
+static unsigned char bobpk[32] = { 0xde, 0x9e, 0xdb, 0x7d, 0x7b, 0x7d, 0xc1,
+                                   0xb4, 0xd3, 0x5b, 0x61, 0xc2, 0xec, 0xe4,
+                                   0x35, 0x37, 0x3f, 0x83, 0x43, 0xc8, 0x5b,
+                                   0x78, 0x67, 0x4d, 0xad, 0xfc, 0x7e, 0x14,
+                                   0x6f, 0x88, 0x2b, 0x4f };
 
 static unsigned char k[32];
 
-int main(void)
+int
+main(void)
 {
     int i;
     int ret;
@@ -28,7 +31,7 @@ int main(void)
         } else {
             printf(" ");
         }
-        printf("0x%02x", (unsigned int)k[i]);
+        printf("0x%02x", (unsigned int) k[i]);
         if (i % 8 == 7) {
             printf("\n");
         }

data/vendor/libsodium/test/default/scalarmult6.c

@@ -2,17 +2,20 @@
 #define TEST_NAME "scalarmult6"
 #include "cmptest.h"
 
-static unsigned char bobsk_[crypto_scalarmult_SCALARBYTES]
-    = { 0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a, 0x4b, 0x79, 0xe1, 0x7f,
-        0x8b, 0x83, 0x80, 0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26, 0x18,
-        0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27, 0xff, 0x88, 0xe0, 0xeb };
-
-static unsigned char alicepk_[crypto_scalarmult_SCALARBYTES]
-    = { 0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b, 0x7d,
-        0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d, 0x26, 0x38,
-        0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b, 0x4e, 0x6a };
-
-int main(void)
+static unsigned char bobsk_[crypto_scalarmult_SCALARBYTES] = {
+    0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a, 0x4b, 0x79, 0xe1, 0x7f,
+    0x8b, 0x83, 0x80, 0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26, 0x18,
+    0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27, 0xff, 0x88, 0xe0, 0xeb
+};
+
+static unsigned char alicepk_[crypto_scalarmult_SCALARBYTES] = {
+    0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b, 0x7d,
+    0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d, 0x26, 0x38,
+    0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b, 0x4e, 0x6a
+};
+
+int
+main(void)
 {
     unsigned char *k;
     unsigned char *bobsk;
@@ -20,8 +23,8 @@ int main(void)
     int            i;
     int            ret;
 
-    k = (unsigned char *) sodium_malloc(crypto_scalarmult_BYTES);
-    bobsk = (unsigned char *) sodium_malloc(crypto_scalarmult_SCALARBYTES);
+    k       = (unsigned char *) sodium_malloc(crypto_scalarmult_BYTES);
+    bobsk   = (unsigned char *) sodium_malloc(crypto_scalarmult_SCALARBYTES);
     alicepk = (unsigned char *) sodium_malloc(crypto_scalarmult_SCALARBYTES);
     assert(k != NULL && bobsk != NULL && alicepk != NULL);
 
@@ -40,7 +43,7 @@ int main(void)
         } else {
             printf(" ");
         }
-        printf("0x%02x", (unsigned int)k[i]);
+        printf("0x%02x", (unsigned int) k[i]);
         if (i % 8 == 7) {
             printf("\n");
         }

data/vendor/libsodium/test/default/scalarmult7.c

@@ -3,29 +3,28 @@
 #include "cmptest.h"
 
 static unsigned char p1[32] = {
-    0x72, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54,
-    0x74, 0x8b, 0x7d, 0xdc, 0xb4, 0x3e, 0xf7, 0x5a,
-    0x0d, 0xbf, 0x3a, 0x0d, 0x26, 0x38, 0x1a, 0xf4,
-    0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b, 0x4e, 0xea
+    0x72, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b, 0x7d,
+    0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d, 0x26, 0x38,
+    0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b, 0x4e, 0xea
 };
 
 static unsigned char p2[32] = {
-    0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54,
-    0x74, 0x8b, 0x7d, 0xdc, 0xb4, 0x3e, 0xf7, 0x5a,
-    0x0d, 0xbf, 0x3a, 0x0d, 0x26, 0x38, 0x1a, 0xf4,
-    0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b, 0x4e, 0x6a
+    0x85, 0x20, 0xf0, 0x09, 0x89, 0x30, 0xa7, 0x54, 0x74, 0x8b, 0x7d,
+    0xdc, 0xb4, 0x3e, 0xf7, 0x5a, 0x0d, 0xbf, 0x3a, 0x0d, 0x26, 0x38,
+    0x1a, 0xf4, 0xeb, 0xa4, 0xa9, 0x8e, 0xaa, 0x9b, 0x4e, 0x6a
 };
 
 static unsigned char scalar[32];
 static unsigned char out1[32];
 static unsigned char out2[32];
 
-int main(void)
+int
+main(void)
 {
     int ret;
 
     scalar[0] = 1U;
-    ret = crypto_scalarmult_curve25519(out1, scalar, p1);
+    ret       = crypto_scalarmult_curve25519(out1, scalar, p1);
     assert(ret == 0);
     ret = crypto_scalarmult_curve25519(out2, scalar, p2);
     assert(ret == 0);