rbnacl-libsodium 1.0.6 → 1.0.7

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

@@ -2,16 +2,18 @@
 #define TEST_NAME "core5"
 #include "cmptest.h"
 
-unsigned char k[32]
+static unsigned char k[32]
     = { 0xee, 0x30, 0x4f, 0xca, 0x27, 0x00, 0x8d, 0x8c, 0x12, 0x6f, 0x90,
         0x02, 0x79, 0x01, 0xd8, 0x0f, 0x7f, 0x1d, 0x8b, 0x8d, 0xc9, 0x36,
         0xcf, 0x3b, 0x9f, 0x81, 0x96, 0x92, 0x82, 0x7e, 0x57, 0x77 };
 
-unsigned char in[16] = { 0x81, 0x91, 0x8e, 0xf2, 0xa5, 0xe0, 0xda, 0x9b,
-                         0x3e, 0x90, 0x60, 0x52, 0x1e, 0x4b, 0xb3, 0x52 };
+static unsigned char in[16]
+    = { 0x81, 0x91, 0x8e, 0xf2, 0xa5, 0xe0, 0xda, 0x9b,
+        0x3e, 0x90, 0x60, 0x52, 0x1e, 0x4b, 0xb3, 0x52 };
 
-unsigned char c[16] = { 101, 120, 112, 97,  110, 100, 32, 51,
-                        50,  45,  98,  121, 116, 101, 32, 107 };
+static unsigned char c[16]
+    = { 101, 120, 112, 97,  110, 100, 32, 51,
+        50,  45,  98,  121, 116, 101, 32, 107 };
 
 unsigned char out[32];
 

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

@@ -2,18 +2,20 @@
 #define TEST_NAME "core6"
 #include "cmptest.h"
 
-unsigned char k[32]
+static unsigned char k[32]
     = { 0xee, 0x30, 0x4f, 0xca, 0x27, 0x00, 0x8d, 0x8c, 0x12, 0x6f, 0x90,
         0x02, 0x79, 0x01, 0xd8, 0x0f, 0x7f, 0x1d, 0x8b, 0x8d, 0xc9, 0x36,
         0xcf, 0x3b, 0x9f, 0x81, 0x96, 0x92, 0x82, 0x7e, 0x57, 0x77 };
 
-unsigned char in[16] = { 0x81, 0x91, 0x8e, 0xf2, 0xa5, 0xe0, 0xda, 0x9b,
-                         0x3e, 0x90, 0x60, 0x52, 0x1e, 0x4b, 0xb3, 0x52 };
+static unsigned char in[16]
+    = { 0x81, 0x91, 0x8e, 0xf2, 0xa5, 0xe0, 0xda, 0x9b,
+        0x3e, 0x90, 0x60, 0x52, 0x1e, 0x4b, 0xb3, 0x52 };
 
-unsigned char c[16] = { 101, 120, 112, 97,  110, 100, 32, 51,
-                        50,  45,  98,  121, 116, 101, 32, 107 };
+static unsigned char c[16]
+    = { 101, 120, 112, 97,  110, 100, 32, 51,
+        50,  45,  98,  121, 116, 101, 32, 107 };
 
-unsigned char out[64];
+static unsigned char out[64];
 
 void print(unsigned char *x, unsigned char *y)
 {

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

@@ -1366,21 +1366,6 @@ main(void)
         printf("%02x", (unsigned int) out[j]);
     }
     printf("\n");
-
-    memset(out, 0, sizeof out);
-    crypto_generichash(out, crypto_generichash_BYTES_MAX, in,
-                       (unsigned long long) i, NULL, 1U);
-    for (j = 0; j < crypto_generichash_BYTES_MAX; ++j) {
-        printf("%02x", (unsigned int) out[j]);
-    }
-    printf("\n");
-
-    assert(crypto_generichash(out, 0U, in, sizeof in, k, sizeof k) == -1);
-    assert(crypto_generichash(out, crypto_generichash_BYTES_MAX + 1U,
-                              in, sizeof in, k, sizeof k) == -1);
-    assert(crypto_generichash(out, sizeof out, in, sizeof in,
-                              k, crypto_generichash_KEYBYTES_MAX + 1U) == -1);
-
     assert(crypto_generichash_bytes_min() > 0U);
     assert(crypto_generichash_bytes_max() > 0U);
     assert(crypto_generichash_bytes() > 0U);

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

@@ -63,4 +63,3 @@ cc66a891768e95a2717b040c111996f14942f10f2475c33aa5f1c97476e6f8386733d6b21c16102d
 bdd3d0fafe8ba2b29d1ac0b79aa46e249cc9d3a82d0f772d690637bbdd353722356658d00436ff5dd5239ab747979329345eb8c7ed11b7331456ae87350fcf
 bd965bf31e87d70327536f2a341cebc4768eca275fa05ef98f7f1b71a0351298de006fba73fe6733ed01d75801b4a928e54231b38e38c562b2e33ea1284992fa
 2fc6e69fa26a89a5ed269092cb9b2a449a4409a7a44011eecad13d7c4b0456602d402fa5844f1a7a758136ce3d5d8d0e8b86921ffff4f692dd95bdc8e5ff0052
-00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

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

@@ -77,8 +77,6 @@ main(void)
         &st, k, crypto_generichash_blake2b_KEYBYTES_MAX,
         crypto_generichash_blake2b_BYTES_MAX, salt, NULL);
     crypto_generichash_blake2b_update(&st, in, MAXLEN);
-    assert(crypto_generichash_blake2b_final(
-        &st, out, crypto_generichash_blake2b_BYTES_MAX + 1U) == -1);
     crypto_generichash_blake2b_final(
         &st, out, crypto_generichash_blake2b_BYTES_MAX);
     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
@@ -98,7 +96,7 @@ main(void)
     memset(out, 0, sizeof out);
     crypto_generichash_blake2b_salt_personal(
         out, crypto_generichash_blake2b_BYTES_MAX, in, MAXLEN,
-        NULL, crypto_generichash_blake2b_KEYBYTES_MAX, salt, personal);
+        NULL, 0U, salt, personal);
     for (j = 0; j < crypto_generichash_blake2b_BYTES_MAX; ++j) {
         printf("%02x", (unsigned int) out[j]);
     }
@@ -149,24 +147,6 @@ main(void)
     }
     printf("\n");
 
-    assert(crypto_generichash_blake2b_init_salt_personal(&st, k, sizeof k, 0U,
-                                                         salt, personal) == -1);
-    assert(crypto_generichash_blake2b_init_salt_personal(&st, k, sizeof k,
-                                                         crypto_generichash_BYTES_MAX + 1U,
-                                                         salt, personal) == -1);
-    assert(crypto_generichash_blake2b_init_salt_personal(&st, k,
-                                                         crypto_generichash_KEYBYTES_MAX + 1U,
-                                                         sizeof out, salt, personal) == -1);
-
-    assert(crypto_generichash_blake2b_salt_personal(out, 0U, in, MAXLEN,
-                                                    k, sizeof k,
-                                                    salt, personal) == -1);
-    assert(crypto_generichash_blake2b_salt_personal(out, crypto_generichash_BYTES_MAX + 1U,
-                                                    in, MAXLEN, k, sizeof k,
-                                                    salt, personal) == -1);
-    assert(crypto_generichash_blake2b_salt_personal(out, sizeof out, in, MAXLEN,
-                                                    k, crypto_generichash_KEYBYTES_MAX + 1U,
-                                                    salt, personal) == -1);
     assert(crypto_generichash_blake2b_init_salt_personal(&st, k, sizeof k, crypto_generichash_BYTES,
                                                          NULL, personal) == 0);
     assert(crypto_generichash_blake2b_init_salt_personal(&st, k, sizeof k, crypto_generichash_BYTES,

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

@@ -67,7 +67,7 @@ c6d6722a916651a8671383d8260873347d9c248696b4cb3dac4dea9ba57ed971127cb18e44211d7e
 5789f474edd5206ededaccfc35e7dd3ed730748125b5395abf802b2601126b19b109a1db67556945bc79bb25e1ab59610599d155070e0e04354f11a6a5d6f3ac
 e78efc663a5547c089f2b3b08973c974c4bfd365eac18b80c68bdb3b1ba4554b54d6b8465a68a3b9aa0bc020621f16efd5b8dd8c7c01ed9ee3ec5544aae465ff
 1afc8ec818bef0a479d2b4cac81d40a52cafa27f6d80c42fc23cbaf4141882ab59ab1101922fcb6e707ef2f61efd07cce5d09094e6bee420b1b96998c7cee96d
-00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+1afc8ec818bef0a479d2b4cac81d40a52cafa27f6d80c42fc23cbaf4141882ab59ab1101922fcb6e707ef2f61efd07cce5d09094e6bee420b1b96998c7cee96d
 fb4e2ad6b7fe6afd2ba06d5c1d79379c5bf10e336a35c89a1aaf408a805171716e0635a5b1d18190131e15b6888510bcb3e3752b050f892a09dbbde60b051495
 5789f474edd5206ededaccfc35e7dd3ed730748125b5395abf802b2601126b19b109a1db67556945bc79bb25e1ab59610599d155070e0e04354f11a6a5d6f3ac
 e78efc663a5547c089f2b3b08973c974c4bfd365eac18b80c68bdb3b1ba4554b54d6b8465a68a3b9aa0bc020621f16efd5b8dd8c7c01ed9ee3ec5544aae465ff

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

@@ -2,9 +2,9 @@
 #define TEST_NAME "hash"
 #include "cmptest.h"
 
-unsigned char x[] = "testing\n";
-unsigned char x2[] = "The Conscience of a Hacker is a small essay written January 8, 1986 by a computer security hacker who went by the handle of The Mentor, who belonged to the 2nd generation of Legion of Doom.";
-unsigned char h[crypto_hash_BYTES];
+static unsigned char x[] = "testing\n";
+static unsigned char x2[] = "The Conscience of a Hacker is a small essay written January 8, 1986 by a computer security hacker who went by the handle of The Mentor, who belonged to the 2nd generation of Legion of Doom.";
+static unsigned char h[crypto_hash_BYTES];
 
 int main(void)
 {

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

@@ -2,8 +2,8 @@
 #define TEST_NAME "hash3"
 #include "cmptest.h"
 
-unsigned char x[] = "testing\n";
-unsigned char h[crypto_hash_BYTES];
+static unsigned char x[] = "testing\n";
+static unsigned char h[crypto_hash_BYTES];
 
 int main(void)
 {

data/vendor/libsodium/test/default/index.html.tpl

@@ -0,0 +1,84 @@
+<!doctype html>
+<html>
+<head>
+<style>
+<meta name="google" content="notranslate" />
+body {
+  background: white;
+  color: black;  
+}
+.test p {
+  margin: 1px;
+}
+.test {
+  font-family: monospace;
+  white-space: pre;   
+}
+.err {
+  background: red;
+  color: white;
+}
+.passed {
+  background: green;
+  color: white; 
+}
+</style>
+</head>
+<body>
+<h1></h1>
+<section class="test" id="test-res"></section>
+<script>
+function runTest(tname) {
+    var xhr, expected, hn, idx = 0, passed = true;
+    
+    function outputReceived(e) {
+        var found = e.data;
+        var p = document.createElement('p');
+        if (found !== expected[idx++]) {
+            p.className = 'err';
+            passed = false;
+        }
+        p.appendChild(document.createTextNode(found));
+        document.getElementById('test-res').appendChild(p);
+        if (idx >= expected.length) {
+            if (passed) {
+                hn.appendChild(document.createTextNode(' - PASSED'));
+                hn.className = 'passed';                    
+            } else {
+                hn.appendChild(document.createTextNode(' - FAILED'));
+                hn.className = 'err';
+            }
+        }        
+    }
+    
+    hn = document.getElementsByTagName('h1')[0];
+    hn.appendChild(document.createTextNode('Test: ' + tname));
+
+    try {
+        xhr = new ActiveXObject('Microsoft.XMLHTTP');
+    } catch (e) {
+        xhr = new XMLHttpRequest();
+    }
+    xhr.open('GET', tname + '.exp');
+    xhr.onreadystatechange = function() {
+        if (xhr.readyState != 4 ||
+            (xhr.status != 200 && xhr.status != 302 && xhr.status != 0)) {
+            return;
+        }
+        expected = xhr.responseText.split('\n');
+        if (expected.length > 0 && expected[expected.length - 1] === '') {
+            expected.pop();
+        }
+        expected.push('--- SUCCESS ---');
+        window.addEventListener('test-output', outputReceived, false);
+        var s = document.getElementsByTagName('script')[0];
+        var st = document.createElement('script');
+        st.src = tname + '.js';
+        s.parentNode.insertBefore(st, s);
+    }
+    xhr.send(null);
+}
+runTest('{{tname}}');
+</script>
+</body>
+</html>

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

@@ -2,12 +2,12 @@
 #define TEST_NAME "onetimeauth"
 #include "cmptest.h"
 
-unsigned char rs[32]
+static unsigned char rs[32]
     = { 0xee, 0xa6, 0xa7, 0x25, 0x1c, 0x1e, 0x72, 0x91, 0x6d, 0x11, 0xc2,
         0xcb, 0x21, 0x4d, 0x3c, 0x25, 0x25, 0x39, 0x12, 0x1d, 0x8e, 0x23,
         0x4e, 0x65, 0x2d, 0x65, 0x1f, 0xa4, 0xc8, 0xcf, 0xf8, 0x80 };
 
-unsigned char c[131]
+static unsigned char c[131]
     = { 0x8e, 0x99, 0x3b, 0x9f, 0x48, 0x68, 0x12, 0x73, 0xc2, 0x96, 0x50, 0xba,
         0x32, 0xfc, 0x76, 0xce, 0x48, 0x33, 0x2e, 0xa7, 0x16, 0x4d, 0x96, 0xa4,
         0x47, 0x6f, 0xb8, 0xc5, 0x31, 0xa1, 0x18, 0x6a, 0xc0, 0xdf, 0xc1, 0x7c,
@@ -20,7 +20,7 @@ unsigned char c[131]
         0x88, 0xd5, 0xf9, 0xb3, 0x79, 0x73, 0xf6, 0x22, 0xa4, 0x3d, 0x14, 0xa6,
         0x59, 0x9b, 0x1f, 0x65, 0x4c, 0xb4, 0x5a, 0x74, 0xe3, 0x55, 0xa5 };
 
-unsigned char a[16];
+static unsigned char a[16];
 
 int main(void)
 {

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

@@ -2,12 +2,12 @@
 #define TEST_NAME "onetimeauth2"
 #include "cmptest.h"
 
-unsigned char rs[32]
+static unsigned char rs[32]
     = { 0xee, 0xa6, 0xa7, 0x25, 0x1c, 0x1e, 0x72, 0x91, 0x6d, 0x11, 0xc2,
         0xcb, 0x21, 0x4d, 0x3c, 0x25, 0x25, 0x39, 0x12, 0x1d, 0x8e, 0x23,
         0x4e, 0x65, 0x2d, 0x65, 0x1f, 0xa4, 0xc8, 0xcf, 0xf8, 0x80 };
 
-unsigned char c[131]
+static unsigned char c[131]
     = { 0x8e, 0x99, 0x3b, 0x9f, 0x48, 0x68, 0x12, 0x73, 0xc2, 0x96, 0x50, 0xba,
         0x32, 0xfc, 0x76, 0xce, 0x48, 0x33, 0x2e, 0xa7, 0x16, 0x4d, 0x96, 0xa4,
         0x47, 0x6f, 0xb8, 0xc5, 0x31, 0xa1, 0x18, 0x6a, 0xc0, 0xdf, 0xc1, 0x7c,
@@ -20,8 +20,9 @@ unsigned char c[131]
         0x88, 0xd5, 0xf9, 0xb3, 0x79, 0x73, 0xf6, 0x22, 0xa4, 0x3d, 0x14, 0xa6,
         0x59, 0x9b, 0x1f, 0x65, 0x4c, 0xb4, 0x5a, 0x74, 0xe3, 0x55, 0xa5 };
 
-unsigned char a[16] = { 0xf3, 0xff, 0xc7, 0x70, 0x3f, 0x94, 0x00, 0xe5,
-                        0x2a, 0x7d, 0xfb, 0x4b, 0x3d, 0x33, 0x05, 0xd9 };
+static unsigned char a[16]
+    = { 0xf3, 0xff, 0xc7, 0x70, 0x3f, 0x94, 0x00, 0xe5,
+        0x2a, 0x7d, 0xfb, 0x4b, 0x3d, 0x33, 0x05, 0xd9 };
 
 int main(void)
 {

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

@@ -2,15 +2,15 @@
 #define TEST_NAME "onetimeauth7"
 #include "cmptest.h"
 
-unsigned char key[32];
-unsigned char c[10000];
-unsigned char a[16];
+static unsigned char key[32];
+static unsigned char c[1000];
+static unsigned char a[16];
 
 int main(void)
 {
     int clen;
 
-    for (clen = 0; clen < 10000; ++clen) {
+    for (clen = 0; clen < 1000; ++clen) {
         randombytes_buf(key, sizeof key);
         randombytes_buf(c, clen);
         crypto_onetimeauth(a, c, clen, key);

data/vendor/libsodium/test/default/pre.js.inc

@@ -4,9 +4,17 @@ try {
 } catch(e) {
     this['Module'] = Module = {};
 }
-Module['preRun'] = Module['preRun'] || [];
-Module['preRun'].push(function(){
-    FS.init();
-    FS.mkdir('/test-data');
-    FS.mount(NODEFS,  { root: '.' }, '/test-data');
-});
+if (typeof process === 'object') {
+    Module['preRun'] = Module['preRun'] || [];
+    Module['preRun'].push(function() {
+        FS.init();
+        FS.mkdir('/test-data');
+        FS.mount(NODEFS,  { root: '.' }, '/test-data');
+    });
+} else {
+    Module['print'] = function(x) {
+        var event = new Event('test-output');
+        event.data = x;
+        window.dispatchEvent(event);
+    };
+}

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

@@ -2,8 +2,8 @@
 #define TEST_NAME "randombytes"
 #include "cmptest.h"
 
-unsigned char x[65536];
-unsigned long long freq[256];
+static unsigned char x[65536];
+static unsigned long long freq[256];
 
 static int compat_tests(void)
 {

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

@@ -2,17 +2,22 @@
 #define TEST_NAME "scalarmult"
 #include "cmptest.h"
 
-const unsigned char alicesk[crypto_scalarmult_BYTES]
+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 };
 
-const unsigned char bobsk[crypto_scalarmult_BYTES]
+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 };
 
-char hex[crypto_scalarmult_BYTES * 2 + 1];
+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)
 {
@@ -22,6 +27,7 @@ int main(void)
         (unsigned char *) sodium_malloc(crypto_scalarmult_BYTES);
     unsigned char *k =
         (unsigned char *) sodium_malloc(crypto_scalarmult_BYTES);
+    int ret;
 
     assert(alicepk != NULL && bobpk != NULL && k != NULL);
 
@@ -33,17 +39,24 @@ int main(void)
     sodium_bin2hex(hex, sizeof hex, bobpk, crypto_scalarmult_BYTES);
     printf("%s\n", hex);
 
-    crypto_scalarmult(k, alicesk, bobpk);
+    ret = crypto_scalarmult(k, alicesk, bobpk);
+    assert(ret == 0);
     sodium_bin2hex(hex, sizeof hex, k, crypto_scalarmult_BYTES);
     printf("%s\n", hex);
 
-    crypto_scalarmult(k, bobsk, alicepk);
+    ret = crypto_scalarmult(k, bobsk, alicepk);
+    assert(ret == 0);
+    sodium_bin2hex(hex, sizeof hex, k, crypto_scalarmult_BYTES);
+    printf("%s\n", hex);
+
+    ret = crypto_scalarmult(k, bobsk, small_order_p);
+    assert(ret == -1);
     sodium_bin2hex(hex, sizeof hex, k, crypto_scalarmult_BYTES);
     printf("%s\n", hex);
 
-    sodium_free(k);
     sodium_free(bobpk);
     sodium_free(alicepk);
+    sodium_free(k);
 
     assert(crypto_scalarmult_bytes() > 0U);
     assert(crypto_scalarmult_scalarbytes() > 0U);

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

@@ -2,3 +2,4 @@
 de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f
 4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742
 4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742
+0000000000000000000000000000000000000000000000000000000000000000

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

@@ -2,12 +2,12 @@
 #define TEST_NAME "scalarmult2"
 #include "cmptest.h"
 
-unsigned char bobsk[32]
+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 };
 
-unsigned char bobpk[32];
+static unsigned char bobpk[32];
 
 int main(void)
 {

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

@@ -2,23 +2,25 @@
 #define TEST_NAME "scalarmult5"
 #include "cmptest.h"
 
-unsigned char alicesk[32]
+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 };
 
-unsigned char bobpk[32]
+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 };
 
-unsigned char k[32];
+static unsigned char k[32];
 
 int main(void)
 {
     int i;
+    int ret;
 
-    crypto_scalarmult(k, alicesk, bobpk);
+    ret = crypto_scalarmult(k, alicesk, bobpk);
+    assert(ret == 0);
 
     for (i = 0; i < 32; ++i) {
         if (i > 0) {