The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
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
8typedef 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
21static 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
31static 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
41static 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
51static 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
61static 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
82static 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
105static 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
127static 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
152static 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
174static 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
199static 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
221static 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
246TEST_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:576
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_encode
#define fr_base64_encode(_out, _in, _add_padding)
Definition base64.h:74
fr_base64_decode
#define fr_base64_decode(_out, _in, _expect_padding, _no_trailing)
Definition base64.h:81
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:209
NUM_ELEMENTS
#define NUM_ELEMENTS(_t)
Definition build.h:337
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.8