1#define TEST_NAME "sodium_utils"
2#include "cmptest.h"
3
4int
5main(void)
6{
7    unsigned char  buf_add[1000];
8    unsigned char  buf1[1000];
9    unsigned char  buf2[1000];
10    unsigned char  buf1_rev[1000];
11    unsigned char  buf2_rev[1000];
12    unsigned char  nonce[24];
13    char           nonce_hex[49];
14    unsigned char *bin_padded;
15    size_t         bin_len, bin_len2;
16    size_t         bin_padded_len;
17    size_t         bin_padded_maxlen;
18    size_t         blocksize;
19    unsigned int   i;
20    unsigned int   j;
21
22    randombytes_buf(buf1, sizeof buf1);
23    memcpy(buf2, buf1, sizeof buf2);
24    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
25    sodium_memzero(buf1, 0U);
26    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
27    sodium_memzero(buf1, sizeof buf1 / 2);
28    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
29    printf("%d\n", sodium_memcmp(buf1, buf2, 0U));
30    sodium_memzero(buf2, sizeof buf2 / 2);
31    printf("%d\n", sodium_memcmp(buf1, buf2, sizeof buf1));
32
33    memset(nonce, 0, sizeof nonce);
34    sodium_increment(nonce, sizeof nonce);
35    printf("%s\n",
36           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
37    memset(nonce, 255, sizeof nonce);
38    sodium_increment(nonce, sizeof nonce);
39    printf("%s\n",
40           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
41    nonce[1] = 1U;
42    sodium_increment(nonce, sizeof nonce);
43    printf("%s\n",
44           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
45    nonce[1] = 0U;
46    sodium_increment(nonce, sizeof nonce);
47    printf("%s\n",
48           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
49    nonce[0] = 255U;
50    nonce[2] = 255U;
51    sodium_increment(nonce, sizeof nonce);
52    printf("%s\n",
53           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
54    for (i = 0U; i < 1000U; i++) {
55        bin_len = (size_t) randombytes_uniform(sizeof buf1);
56        randombytes_buf(buf1, bin_len);
57        randombytes_buf(buf2, bin_len);
58        for (j = 0U; j < bin_len; j++) {
59            buf1_rev[bin_len - 1 - j] = buf1[j];
60            buf2_rev[bin_len - 1 - j] = buf2[j];
61        }
62        if (memcmp(buf1_rev, buf2_rev, bin_len) *
63                sodium_compare(buf1, buf2, bin_len) <
64            0) {
65            printf("sodium_compare() failure with length=%u\n",
66                   (unsigned int) bin_len);
67        }
68        memcpy(buf1, buf2, bin_len);
69        if (sodium_compare(buf1, buf2, bin_len)) {
70            printf("sodium_compare() equality failure with length=%u\n",
71                   (unsigned int) bin_len);
72        }
73    }
74    memset(buf1, 0, sizeof buf1);
75    if (sodium_is_zero(buf1, sizeof buf1) != 1) {
76        printf("sodium_is_zero() failed\n");
77    }
78    for (i = 0U; i < sizeof buf1; i++) {
79        buf1[i]++;
80        if (sodium_is_zero(buf1, sizeof buf1) != 0) {
81            printf("sodium_is_zero() failed\n");
82        }
83        buf1[i]--;
84    }
85    bin_len = randombytes_uniform(sizeof buf1);
86    randombytes_buf(buf1, bin_len);
87    memcpy(buf2, buf1, bin_len);
88    memset(buf_add, 0, bin_len);
89    j = randombytes_uniform(10000);
90    for (i = 0U; i < j; i++) {
91        sodium_increment(buf1, bin_len);
92        sodium_increment(buf_add, bin_len);
93    }
94    sodium_add(buf2, buf_add, bin_len);
95    if (sodium_compare(buf1, buf2, bin_len) != 0) {
96        printf("sodium_add() failed\n");
97    }
98    bin_len = randombytes_uniform(sizeof buf1);
99    randombytes_buf(buf1, bin_len);
100    memcpy(buf2, buf1, bin_len);
101    memset(buf_add, 0xff, bin_len);
102    sodium_increment(buf2, bin_len);
103    sodium_increment(buf2, 0U);
104    sodium_add(buf2, buf_add, bin_len);
105    sodium_add(buf2, buf_add, 0U);
106    if (sodium_compare(buf1, buf2, bin_len) != 0) {
107        printf("sodium_add() failed\n");
108    }
109
110    assert(sizeof nonce >= 24U);
111    memset(nonce, 0xfe, 24U);
112    memset(nonce, 0xff, 6U);
113    sodium_increment(nonce, 8U);
114    printf("%s\n",
115           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
116    memset(nonce, 0xfe, 24U);
117    memset(nonce, 0xff, 10U);
118    sodium_increment(nonce, 12U);
119    printf("%s\n",
120           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
121    memset(nonce, 0xff, 22U);
122    sodium_increment(nonce, 24U);
123    printf("%s\n",
124           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
125
126    assert(sizeof nonce >= 24U);
127    memset(nonce, 0xfe, 24U);
128    memset(nonce, 0xff, 6U);
129    sodium_add(nonce, nonce, 7U);
130    sodium_add(nonce, nonce, 8U);
131    printf("%s\n",
132           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
133    memset(nonce, 0xfe, 24U);
134    memset(nonce, 0xff, 10U);
135    sodium_add(nonce, nonce, 11U);
136    sodium_add(nonce, nonce, 12U);
137    printf("%s\n",
138           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
139    memset(nonce, 0xff, 22U);
140    sodium_add(nonce, nonce, 23U);
141    sodium_add(nonce, nonce, 24U);
142    printf("%s\n",
143           sodium_bin2hex(nonce_hex, sizeof nonce_hex, nonce, sizeof nonce));
144
145    for (i = 0; i < 2000U; i++) {
146        bin_len = randombytes_uniform(200U);
147        blocksize = 1U + randombytes_uniform(100U);
148        bin_padded_maxlen = bin_len + (blocksize - bin_len % blocksize);
149        bin_padded = (unsigned char *) sodium_malloc(bin_padded_maxlen);
150        randombytes_buf(bin_padded, bin_padded_maxlen);
151
152        assert(sodium_pad(&bin_padded_len, bin_padded, bin_len,
153                          blocksize, bin_padded_maxlen - 1U) == -1);
154        assert(sodium_pad(NULL, bin_padded, bin_len,
155                          blocksize, bin_padded_maxlen + 1U) == 0);
156        assert(sodium_pad(&bin_padded_len, bin_padded, bin_len,
157                          blocksize, bin_padded_maxlen + 1U) == 0);
158        assert(sodium_pad(&bin_padded_len, bin_padded, bin_len,
159                          0U, bin_padded_maxlen) == -1);
160        assert(sodium_pad(&bin_padded_len, bin_padded, bin_len,
161                          blocksize, bin_padded_maxlen) == 0);
162        assert(bin_padded_len == bin_padded_maxlen);
163
164        assert(sodium_unpad(&bin_len2, bin_padded, bin_padded_len,
165                            bin_padded_len + 1U) == -1);
166        assert(sodium_unpad(&bin_len2, bin_padded, bin_padded_len,
167                            0U) == -1);
168        assert(sodium_unpad(&bin_len2, bin_padded, bin_padded_len,
169                            blocksize) == 0);
170        assert(bin_len2 == bin_len);
171
172        sodium_free(bin_padded);
173    }
174
175    sodium_stackzero(512);
176
177    return 0;
178}
179