The FreeRADIUS server  $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
base_16_32_64_tests.c
Go to the documentation of this file.
1 #include <freeradius-devel/util/acutest.h>
2 #include <freeradius-devel/util/acutest_helpers.h>
3 
4 #include "base16.h"
5 #include "base32.h"
6 #include "base64.h"
7 
8 typedef struct {
9  struct {
10  char const *str;
11  size_t len;
12  } cleartext;
13 
14  struct {
15  char const *str;
16  size_t len;
17  } encoded;
18 } test_vector;
19 
20 
21 static const test_vector base16_vectors[] = {
22  { L(""), L("") },
23  { L("f"), L("66") },
24  { L("fo"), L("666f") },
25  { L("foo"), L("666f6f") },
26  { L("foob"), L("666f6f62") },
27  { L("fooba"), L("666f6f6261") },
28  { L("foobar"), L("666f6f626172") }
29 };
30 
31 static const test_vector base32_vectors[] = {
32  { L(""), L("") },
33  { L("f"), L("MY======") },
34  { L("fo"), L("MZXQ====") },
35  { L("foo"), L("MZXW6===") },
36  { L("foob"), L("MZXW6YQ=") },
37  { L("fooba"), L("MZXW6YTB") },
38  { L("foobar"), L("MZXW6YTBOI======") }
39 };
40 
41 static const test_vector base32_hex_vectors[] = {
42  { L(""), L("") },
43  { L("f"), L("CO======") },
44  { L("fo"), L("CPNG====") },
45  { L("foo"), L("CPNMU===") },
46  { L("foob"), L("CPNMUOG=") },
47  { L("fooba"), L("CPNMUOJ1") },
48  { L("foobar"), L("CPNMUOJ1E8======") }
49 };
50 
51 static const test_vector base64_vectors[] = {
52  { L(""), L("") },
53  { L("f"), L("Zg==") },
54  { L("fo"), L("Zm8=") },
55  { L("foo"), L("Zm9v") },
56  { L("foob"), L("Zm9vYg==") },
57  { L("fooba"), L("Zm9vYmE=") },
58  { L("foobar"), L("Zm9vYmFy") }
59 };
60 
61 static void test_base16_encode(void)
62 {
63  char buffer[17] = { 0xff }; /* Initialise to catch bad terminators */
64  fr_sbuff_t out;
65  size_t i;
66 
67  fr_sbuff_init_out(&out, buffer, sizeof(buffer));
68 
69  for (i = 0; i < NUM_ELEMENTS(base16_vectors); i++) {
70  fr_sbuff_set_to_start(&out);
71  TEST_CHECK_SLEN(fr_base16_encode(&out,
72  &FR_DBUFF_TMP((uint8_t const *)base16_vectors[i].cleartext.str,
73  base16_vectors[i].cleartext.len)),
74  (ssize_t)base16_vectors[i].encoded.len);
75  TEST_MSG("%s", fr_strerror());
76 
77  fr_sbuff_set_to_start(&out);
78  TEST_CHECK_STRCMP(fr_sbuff_current(&out), base16_vectors[i].encoded.str);
79  }
80 }
81 
82 static void test_base16_decode(void)
83 {
84  char buffer[7] = { 0xff }; /* Initialise to catch bad terminators */
85  fr_dbuff_t out;
86  size_t i;
87 
88  fr_dbuff_init(&out, (uint8_t *)buffer, sizeof(buffer));
89 
90  for (i = 0; i < NUM_ELEMENTS(base16_vectors); i++) {
91  fr_dbuff_set_to_start(&out);
92  TEST_CHECK_SLEN(fr_base16_decode(NULL, &out,
93  &FR_SBUFF_IN(base16_vectors[i].encoded.str,
94  base16_vectors[i].encoded.len), true),
95  (ssize_t)base16_vectors[i].cleartext.len);
96  TEST_MSG("%s", fr_strerror());
97 
98  fr_dbuff_in_bytes(&out, 0x00); /* Terminate */
99 
100  fr_dbuff_set_to_start(&out);
101  TEST_CHECK_STRCMP((char *)fr_dbuff_current(&out), base16_vectors[i].cleartext.str);
102  }
103 }
104 
105 static void test_base32_encode(void)
106 {
107  char buffer[17] = { 0xff }; /* Initialise to catch bad terminators */
108  fr_sbuff_t out;
109  size_t i;
110 
111  fr_sbuff_init_out(&out, buffer, sizeof(buffer));
112 
113  for (i = 0; i < NUM_ELEMENTS(base32_vectors); i++) {
114  fr_sbuff_set_to_start(&out);
115  TEST_CHECK_SLEN(fr_base32_encode(&out,
116  &FR_DBUFF_TMP((uint8_t const *)base32_vectors[i].cleartext.str,
117  base32_vectors[i].cleartext.len),
118  true),
119  (ssize_t)base32_vectors[i].encoded.len);
120  TEST_MSG("%s", fr_strerror());
121 
122  fr_sbuff_set_to_start(&out);
123  TEST_CHECK_STRCMP(fr_sbuff_current(&out), base32_vectors[i].encoded.str);
124  }
125 }
126 
127 static void test_base32_decode(void)
128 {
129  char buffer[7] = { 0xff }; /* Initialise to catch bad terminators */
130  fr_dbuff_t out;
131  size_t i;
132 
133  fr_dbuff_init(&out, (uint8_t *)buffer, sizeof(buffer));
134 
135  for (i = 0; i < NUM_ELEMENTS(base32_vectors); i++) {
136  fr_dbuff_set_to_start(&out);
137  TEST_CHECK_SLEN(fr_base32_decode(&out,
138  &FR_SBUFF_IN(base32_vectors[i].encoded.str,
139  base32_vectors[i].encoded.len),
140  true, true),
141  (ssize_t)base32_vectors[i].cleartext.len);
142  TEST_MSG("%s", fr_strerror());
143 
144  fr_dbuff_in_bytes(&out, 0x00); /* Terminate */
145 
146  fr_dbuff_set_to_start(&out);
147  TEST_CHECK_STRCMP((char *)fr_dbuff_current(&out), base32_vectors[i].cleartext.str);
148 
149  }
150 }
151 
152 static void test_base32_hex_encode(void)
153 {
154  char buffer[17] = { 0xff }; /* Initialise to catch bad terminators */
155  fr_sbuff_t out;
156  size_t i;
157 
158  fr_sbuff_init_out(&out, buffer, sizeof(buffer));
159 
160  for (i = 0; i < NUM_ELEMENTS(base32_hex_vectors); i++) {
161  fr_sbuff_set_to_start(&out);
162  TEST_CHECK_SLEN(fr_base32_encode_nstd(&out,
163  &FR_DBUFF_TMP((uint8_t const *)base32_hex_vectors[i].cleartext.str,
164  base32_hex_vectors[i].cleartext.len),
165  true, fr_base32_hex_alphabet_encode),
166  (ssize_t)base32_hex_vectors[i].encoded.len);
167  TEST_MSG("%s", fr_strerror());
168 
169  fr_sbuff_set_to_start(&out);
170  TEST_CHECK_STRCMP(fr_sbuff_current(&out), base32_hex_vectors[i].encoded.str);
171  }
172 }
173 
174 static void test_base32_hex_decode(void)
175 {
176  char buffer[7] = { 0xff }; /* Initialise to catch bad terminators */
177  fr_dbuff_t out;
178  size_t i;
179 
180  fr_dbuff_init(&out, (uint8_t *)buffer, sizeof(buffer));
181 
182  for (i = 0; i < NUM_ELEMENTS(base32_vectors); i++) {
183  fr_dbuff_set_to_start(&out);
184  TEST_CHECK_SLEN(fr_base32_decode_nstd(NULL, &out,
185  &FR_SBUFF_IN(base32_hex_vectors[i].encoded.str,
186  base32_hex_vectors[i].encoded.len),
187  true, true, fr_base32_hex_alphabet_decode),
188  (ssize_t)base32_hex_vectors[i].cleartext.len);
189  TEST_MSG("%s", fr_strerror());
190 
191  fr_dbuff_in_bytes(&out, 0x00); /* Terminate */
192 
193  fr_dbuff_set_to_start(&out);
194  TEST_CHECK_STRCMP((char *)fr_dbuff_current(&out), base32_hex_vectors[i].cleartext.str);
195 
196  }
197 }
198 
199 static void test_base64_encode(void)
200 {
201  char buffer[17] = { 0xff }; /* Initialise to catch bad terminators */
202  fr_sbuff_t out;
203  size_t i;
204 
205  fr_sbuff_init_out(&out, buffer, sizeof(buffer));
206 
207  for (i = 0; i < NUM_ELEMENTS(base64_vectors); i++) {
208  fr_sbuff_set_to_start(&out);
209  TEST_CHECK_SLEN(fr_base64_encode(&out,
210  &FR_DBUFF_TMP((uint8_t const *)base64_vectors[i].cleartext.str,
211  base64_vectors[i].cleartext.len),
212  true),
213  (ssize_t)base64_vectors[i].encoded.len);
214  TEST_MSG("%s", fr_strerror());
215 
216  fr_sbuff_set_to_start(&out);
217  TEST_CHECK_STRCMP(fr_sbuff_current(&out), base64_vectors[i].encoded.str);
218  }
219 }
220 
221 static void test_base64_decode(void)
222 {
223  char buffer[7] = { 0xff }; /* Initialise to catch bad terminators */
224  fr_dbuff_t out;
225  size_t i;
226 
227  fr_dbuff_init(&out, (uint8_t *)buffer, sizeof(buffer));
228 
229  for (i = 0; i < NUM_ELEMENTS(base64_vectors); i++) {
230  fr_dbuff_set_to_start(&out);
231  TEST_CHECK_SLEN(fr_base64_decode(&out,
232  &FR_SBUFF_IN(base64_vectors[i].encoded.str,
233  base64_vectors[i].encoded.len),
234  true, true),
235  (ssize_t)base64_vectors[i].cleartext.len);
236  TEST_MSG("%s", fr_strerror());
237 
238  fr_dbuff_in_bytes(&out, 0x00); /* Terminate */
239 
240  fr_dbuff_set_to_start(&out);
241  TEST_CHECK_STRCMP((char *)fr_dbuff_current(&out), base64_vectors[i].cleartext.str);
242 
243  }
244 }
245 
246 TEST_LIST = {
247  { "base16_encode", test_base16_encode },
248  { "base16_decode", test_base16_decode },
249 
250  { "base32_encode", test_base32_encode },
251  { "base32_decode", test_base32_decode },
252  { "base32_hex_encode", test_base32_hex_encode },
253  { "base32_hex_decode", test_base32_hex_decode },
254 
255  { "base64.encode", test_base64_encode },
256  { "base64.decode", test_base64_decode },
257  { NULL }
258 };
buffer
static int const char char buffer[256]
Definition: acutest.h:574
TEST_MSG
#define TEST_MSG(...)
Definition: acutest.h:215
TEST_CHECK_SLEN
#define TEST_CHECK_SLEN(_got, _exp)
Definition: acutest_helpers.h:38
TEST_CHECK_STRCMP
#define TEST_CHECK_STRCMP(_got, _exp)
Definition: acutest_helpers.h:63
fr_base16_encode
#define fr_base16_encode(_out, _in)
Definition: base16.h:57
fr_base16_decode
#define fr_base16_decode(_err, _out, _in, _no_trailing)
Definition: base16.h:95
fr_base32_encode_nstd
ssize_t fr_base32_encode_nstd(fr_sbuff_t *out, fr_dbuff_t *in, bool add_padding, char const alphabet[static UINT8_MAX])
Base 64 encode binary data.
Definition: base32.c:190
fr_base32_hex_alphabet_decode
uint8_t const fr_base32_hex_alphabet_decode[UINT8_MAX]
Definition: base32.c:140
fr_base32_decode_nstd
fr_slen_t fr_base32_decode_nstd(fr_sbuff_parse_error_t *err, fr_dbuff_t *out, fr_sbuff_t *in, bool expect_padding, bool no_trailing, uint8_t const alphabet[static UINT8_MAX])
Definition: base32.c:315
fr_base32_hex_alphabet_encode
char const fr_base32_hex_alphabet_encode[UINT8_MAX]
Definition: base32.c:105
fr_base32_encode
#define fr_base32_encode(_out, _in, _add_padding)
Definition: base32.h:62
fr_base32_decode
#define fr_base32_decode(_out, _in, _expect_padding, _no_trailing)
Definition: base32.h:69
fr_base64_decode
#define fr_base64_decode(_out, _in, _expect_padding, _no_trailing)
Definition: base64.h:81
fr_base64_encode
size_t fr_base64_encode(char *restrict out, size_t outlen, uint8_t const *restrict in, size_t inlen)
TEST_LIST
TEST_LIST
Definition: base_16_32_64_tests.c:246
test_base64_decode
static void test_base64_decode(void)
Definition: base_16_32_64_tests.c:221
test_vector::encoded
struct test_vector::@106 encoded
test_base64_encode
static void test_base64_encode(void)
Definition: base_16_32_64_tests.c:199
base32_hex_vectors
static const test_vector base32_hex_vectors[]
Definition: base_16_32_64_tests.c:41
test_base16_encode
static void test_base16_encode(void)
Definition: base_16_32_64_tests.c:61
test_base32_hex_encode
static void test_base32_hex_encode(void)
Definition: base_16_32_64_tests.c:152
test_vector::cleartext
struct test_vector::@105 cleartext
base32_vectors
static const test_vector base32_vectors[]
Definition: base_16_32_64_tests.c:31
test_base32_encode
static void test_base32_encode(void)
Definition: base_16_32_64_tests.c:105
base16_vectors
static const test_vector base16_vectors[]
Definition: base_16_32_64_tests.c:21
test_base32_hex_decode
static void test_base32_hex_decode(void)
Definition: base_16_32_64_tests.c:174
test_base32_decode
static void test_base32_decode(void)
Definition: base_16_32_64_tests.c:127
test_base16_decode
static void test_base16_decode(void)
Definition: base_16_32_64_tests.c:82
base64_vectors
static const test_vector base64_vectors[]
Definition: base_16_32_64_tests.c:51
test_vector
Definition: base_16_32_64_tests.c:8
L
#define L(_str)
Helper for initialising arrays of string literals.
Definition: build.h:207
NUM_ELEMENTS
#define NUM_ELEMENTS(_t)
Definition: build.h:335
fr_dbuff_current
#define fr_dbuff_current(_dbuff_or_marker)
Return the 'current' position of a dbuff or marker.
Definition: dbuff.h:911
fr_dbuff_init
#define fr_dbuff_init(_out, _start, _len_or_end)
Initialise an dbuff for encoding or decoding.
Definition: dbuff.h:354
fr_dbuff_set_to_start
#define fr_dbuff_set_to_start(_dbuff_or_marker)
Reset the 'current' position of the dbuff or marker to the 'start' of the buffer.
Definition: dbuff.h:1155
fr_dbuff_in_bytes
#define fr_dbuff_in_bytes(_dbuff_or_marker,...)
Copy a byte sequence into a dbuff or marker.
Definition: dbuff.h:1465
FR_DBUFF_TMP
#define FR_DBUFF_TMP(_start, _len_or_end)
Creates a compound literal to pass into functions which accept a dbuff.
Definition: dbuff.h:514
ssize_t
long int ssize_t
Definition: merged_model.c:24
uint8_t
unsigned char uint8_t
Definition: merged_model.c:30
fr_dbuff_t
Definition: merged_model.c:41
fr_sbuff_t
Definition: merged_model.c:37
FR_SBUFF_IN
#define FR_SBUFF_IN(_start, _len_or_end)
fr_sbuff_current
#define fr_sbuff_current(_sbuff_or_marker)
fr_sbuff_init_out
#define fr_sbuff_init_out(_out, _start, _len_or_end)
fr_strerror
char const * fr_strerror(void)
Get the last library error.
Definition: strerror.c:554
out
static size_t char ** out
Definition: value.h:997
Generated by   doxygen 1.9.1