Debian Codegraph @

regress/unittests/sshbuf/test_sshbuf_misc.c

raw
1 /* $OpenBSD: test_sshbuf_misc.c,v 1.7 2025/09/15 03:00:22 djm Exp $ */
2 /*
3 * Regress test for sshbuf.h buffer API
4 *
5 * Placed in the public domain
6 */
7
8 #include "includes.h"
9
10 #include <sys/types.h>
11 #include <stdio.h>
12 #include <stdint.h>
13 #include <stdlib.h>
14 #include <string.h>
15
16 #include "../test_helper/test_helper.h"
17
18 #include "sshbuf.h"
19 #include "ssherr.h"
20
21 void sshbuf_misc_tests(void);
22
23 static void
24 test_sshbuf_dump(void)
25 {
26 struct sshbuf *p1;
27 char tmp[512];
28 FILE *out;
29 size_t sz;
30
31 TEST_START("sshbuf_dump");
32 out = tmpfile();
33 ASSERT_PTR_NE(out, NULL);
34 p1 = sshbuf_new();
35 ASSERT_PTR_NE(p1, NULL);
36 ASSERT_INT_EQ(sshbuf_put_u32(p1, 0x12345678), 0);
37 sshbuf_dump(p1, out);
38 fflush(out);
39 rewind(out);
40 sz = fread(tmp, 1, sizeof(tmp), out);
41 ASSERT_INT_EQ(ferror(out), 0);
42 ASSERT_INT_NE(feof(out), 0);
43 ASSERT_SIZE_T_GT(sz, 0);
44 tmp[sz] = '\0';
45 ASSERT_PTR_NE(strstr(tmp, "12 34 56 78"), NULL);
46 fclose(out);
47 sshbuf_free(p1);
48 TEST_DONE();
49 }
50
51 static void
52 test_sshbuf_dtob16(void)
53 {
54 struct sshbuf *p1;
55 char *p;
56
57 TEST_START("sshbuf_dtob16");
58 p1 = sshbuf_new();
59 ASSERT_PTR_NE(p1, NULL);
60 ASSERT_INT_EQ(sshbuf_put_u32(p1, 0x12345678), 0);
61 p = sshbuf_dtob16(p1);
62 ASSERT_PTR_NE(p, NULL);
63 ASSERT_STRING_EQ(p, "12345678");
64 free(p);
65 sshbuf_free(p1);
66 TEST_DONE();
67 }
68
69 static void
70 test_sshbuf_dtob64_string(void)
71 {
72 struct sshbuf *p1;
73 char *p;
74
75 TEST_START("sshbuf_dtob64_string len 1");
76 p1 = sshbuf_new();
77 ASSERT_PTR_NE(p1, NULL);
78 ASSERT_INT_EQ(sshbuf_put_u8(p1, 0x11), 0);
79 p = sshbuf_dtob64_string(p1, 0);
80 ASSERT_PTR_NE(p, NULL);
81 ASSERT_STRING_EQ(p, "EQ==");
82 free(p);
83 sshbuf_free(p1);
84 TEST_DONE();
85
86 TEST_START("sshbuf_dtob64_string len 2");
87 p1 = sshbuf_new();
88 ASSERT_PTR_NE(p1, NULL);
89 ASSERT_INT_EQ(sshbuf_put_u8(p1, 0x11), 0);
90 ASSERT_INT_EQ(sshbuf_put_u8(p1, 0x22), 0);
91 p = sshbuf_dtob64_string(p1, 0);
92 ASSERT_PTR_NE(p, NULL);
93 ASSERT_STRING_EQ(p, "ESI=");
94 free(p);
95 sshbuf_free(p1);
96 TEST_DONE();
97
98 TEST_START("sshbuf_dtob64_string len 3");
99 p1 = sshbuf_new();
100 ASSERT_PTR_NE(p1, NULL);
101 ASSERT_INT_EQ(sshbuf_put_u8(p1, 0x11), 0);
102 ASSERT_INT_EQ(sshbuf_put_u8(p1, 0x22), 0);
103 ASSERT_INT_EQ(sshbuf_put_u8(p1, 0x33), 0);
104 p = sshbuf_dtob64_string(p1, 0);
105 ASSERT_PTR_NE(p, NULL);
106 ASSERT_STRING_EQ(p, "ESIz");
107 free(p);
108 sshbuf_free(p1);
109 TEST_DONE();
110
111 TEST_START("sshbuf_dtob64_string len 8191");
112 p1 = sshbuf_new();
113 ASSERT_PTR_NE(p1, NULL);
114 ASSERT_INT_EQ(sshbuf_reserve(p1, 8192, NULL), 0);
115 bzero(sshbuf_mutable_ptr(p1), 8192);
116 p = sshbuf_dtob64_string(p1, 0);
117 ASSERT_PTR_NE(p, NULL);
118 ASSERT_SIZE_T_EQ(strlen(p), ((8191 + 2) / 3) * 4);
119 free(p);
120 sshbuf_free(p1);
121 TEST_DONE();
122 }
123
124 static void
125 test_sshbuf_b64tod(void)
126 {
127 struct sshbuf *p1;
128
129 TEST_START("sshbuf_b64tod len 1");
130 p1 = sshbuf_new();
131 ASSERT_PTR_NE(p1, NULL);
132 ASSERT_INT_EQ(sshbuf_b64tod(p1, "0A=="), 0);
133 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1);
134 ASSERT_U8_EQ(*sshbuf_ptr(p1), 0xd0);
135 sshbuf_free(p1);
136 TEST_DONE();
137
138 TEST_START("sshbuf_b64tod len 2");
139 p1 = sshbuf_new();
140 ASSERT_PTR_NE(p1, NULL);
141 ASSERT_INT_EQ(sshbuf_b64tod(p1, "0A8="), 0);
142 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 2);
143 ASSERT_U16_EQ(PEEK_U16(sshbuf_ptr(p1)), 0xd00f);
144 sshbuf_free(p1);
145 TEST_DONE();
146
147 TEST_START("sshbuf_b64tod len 4");
148 p1 = sshbuf_new();
149 ASSERT_PTR_NE(p1, NULL);
150 ASSERT_INT_EQ(sshbuf_b64tod(p1, "0A/QDw=="), 0);
151 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 4);
152 ASSERT_U32_EQ(PEEK_U32(sshbuf_ptr(p1)), 0xd00fd00f);
153 sshbuf_free(p1);
154 TEST_DONE();
155 }
156
157 static void
158 test_sshbuf_dup_string(void)
159 {
160 struct sshbuf *p1;
161 char *p;
162
163 TEST_START("sshbuf_dup_string");
164 p1 = sshbuf_new();
165 ASSERT_PTR_NE(p1, NULL);
166 /* Check empty buffer */
167 p = sshbuf_dup_string(p1);
168 ASSERT_PTR_NE(p, NULL);
169 ASSERT_SIZE_T_EQ(strlen(p), 0);
170 free(p);
171 /* Check buffer with string */
172 ASSERT_INT_EQ(sshbuf_put(p1, "quad1", strlen("quad1")), 0);
173 p = sshbuf_dup_string(p1);
174 ASSERT_PTR_NE(p, NULL);
175 ASSERT_SIZE_T_EQ(strlen(p), strlen("quad1"));
176 ASSERT_STRING_EQ(p, "quad1");
177 free(p);
178 /* Check buffer with terminating nul */
179 ASSERT_INT_EQ(sshbuf_put(p1, "\0", 1), 0);
180 p = sshbuf_dup_string(p1);
181 ASSERT_PTR_NE(p, NULL);
182 ASSERT_SIZE_T_EQ(strlen(p), strlen("quad1"));
183 ASSERT_STRING_EQ(p, "quad1");
184 free(p);
185 /* Check buffer with data after nul (expect failure) */
186 ASSERT_INT_EQ(sshbuf_put(p1, "quad2", strlen("quad2")), 0);
187 p = sshbuf_dup_string(p1);
188 ASSERT_PTR_EQ(p, NULL);
189 sshbuf_free(p1);
190 TEST_DONE();
191 }
192
193 static void
194 test_sshbuf_cmp(void)
195 {
196 struct sshbuf *p1;
197 char msg[] = "imploring ping silence ping over";
198
199 TEST_START("sshbuf_cmp");
200 p1 = sshbuf_from(msg, sizeof(msg) - 1);
201 ASSERT_PTR_NE(p1, NULL);
202 ASSERT_INT_EQ(sshbuf_cmp(p1, 0, "i", 1), 0);
203 ASSERT_INT_EQ(sshbuf_cmp(p1, 0, "j", 1), SSH_ERR_INVALID_FORMAT);
204 ASSERT_INT_EQ(sshbuf_cmp(p1, 0, "imploring", 9), 0);
205 ASSERT_INT_EQ(sshbuf_cmp(p1, 0, "implored", 9), SSH_ERR_INVALID_FORMAT);
206 ASSERT_INT_EQ(sshbuf_cmp(p1, 10, "ping", 4), 0);
207 ASSERT_INT_EQ(sshbuf_cmp(p1, 10, "ring", 4), SSH_ERR_INVALID_FORMAT);
208 ASSERT_INT_EQ(sshbuf_cmp(p1, 28, "over", 4), 0);
209 ASSERT_INT_EQ(sshbuf_cmp(p1, 28, "rove", 4), SSH_ERR_INVALID_FORMAT);
210 ASSERT_INT_EQ(sshbuf_cmp(p1, 28, "overt", 5),
211 SSH_ERR_MESSAGE_INCOMPLETE);
212 ASSERT_INT_EQ(sshbuf_cmp(p1, 32, "ping", 4),
213 SSH_ERR_MESSAGE_INCOMPLETE);
214 ASSERT_INT_EQ(sshbuf_cmp(p1, 1000, "silence", 7),
215 SSH_ERR_MESSAGE_INCOMPLETE);
216 ASSERT_INT_EQ(sshbuf_cmp(p1, 0, msg, sizeof(msg) - 1), 0);
217 sshbuf_free(p1);
218 TEST_DONE();
219 }
220
221 static void
222 test_sshbuf_find(void)
223 {
224 struct sshbuf *p1;
225 char msg[] = "imploring ping silence ping over";
226 size_t sz;
227
228 TEST_START("sshbuf_find");
229 p1 = sshbuf_from(msg, sizeof(msg) - 1);
230 ASSERT_PTR_NE(p1, NULL);
231 ASSERT_INT_EQ(sshbuf_find(p1, 0, "i", 1, &sz), 0);
232 ASSERT_SIZE_T_EQ(sz, 0);
233 ASSERT_INT_EQ(sshbuf_find(p1, 0, "j", 1, &sz), SSH_ERR_INVALID_FORMAT);
234 ASSERT_INT_EQ(sshbuf_find(p1, 0, "imploring", 9, &sz), 0);
235 ASSERT_SIZE_T_EQ(sz, 0);
236 ASSERT_INT_EQ(sshbuf_find(p1, 0, "implored", 9, &sz),
237 SSH_ERR_INVALID_FORMAT);
238 ASSERT_INT_EQ(sshbuf_find(p1, 3, "ping", 4, &sz), 0);
239 ASSERT_SIZE_T_EQ(sz, 10);
240 ASSERT_INT_EQ(sshbuf_find(p1, 11, "ping", 4, &sz), 0);
241 ASSERT_SIZE_T_EQ(sz, 23);
242 ASSERT_INT_EQ(sshbuf_find(p1, 20, "over", 4, &sz), 0);
243 ASSERT_SIZE_T_EQ(sz, 28);
244 ASSERT_INT_EQ(sshbuf_find(p1, 28, "over", 4, &sz), 0);
245 ASSERT_SIZE_T_EQ(sz, 28);
246 ASSERT_INT_EQ(sshbuf_find(p1, 28, "rove", 4, &sz),
247 SSH_ERR_INVALID_FORMAT);
248 ASSERT_INT_EQ(sshbuf_find(p1, 28, "overt", 5, &sz),
249 SSH_ERR_MESSAGE_INCOMPLETE);
250 ASSERT_INT_EQ(sshbuf_find(p1, 32, "ping", 4, &sz),
251 SSH_ERR_MESSAGE_INCOMPLETE);
252 ASSERT_INT_EQ(sshbuf_find(p1, 1000, "silence", 7, &sz),
253 SSH_ERR_MESSAGE_INCOMPLETE);
254 ASSERT_INT_EQ(sshbuf_find(p1, 0, msg + 1, sizeof(msg) - 2, &sz), 0);
255 ASSERT_SIZE_T_EQ(sz, 1);
256 sshbuf_free(p1);
257 TEST_DONE();
258 }
259
260 static void
261 test_sshbuf_equals(void)
262 {
263 struct sshbuf *b1, *b2;
264
265 TEST_START("sshbuf_equals identical");
266 b1 = sshbuf_new();
267 b2 = sshbuf_new();
268 ASSERT_PTR_NE(b1, NULL);
269 ASSERT_PTR_NE(b2, NULL);
270 ASSERT_INT_EQ(sshbuf_put(b1, "hello", 5), 0);
271 ASSERT_INT_EQ(sshbuf_put(b2, "hello", 5), 0);
272 ASSERT_INT_EQ(sshbuf_equals(b1, b2), 0);
273 sshbuf_free(b1);
274 sshbuf_free(b2);
275 TEST_DONE();
276
277 TEST_START("sshbuf_equals different content");
278 b1 = sshbuf_new();
279 b2 = sshbuf_new();
280 ASSERT_PTR_NE(b1, NULL);
281 ASSERT_PTR_NE(b2, NULL);
282 ASSERT_INT_EQ(sshbuf_put(b1, "hello", 5), 0);
283 ASSERT_INT_EQ(sshbuf_put(b2, "world", 5), 0);
284 ASSERT_INT_EQ(sshbuf_equals(b1, b2), SSH_ERR_INVALID_FORMAT);
285 sshbuf_free(b1);
286 sshbuf_free(b2);
287 TEST_DONE();
288
289 TEST_START("sshbuf_equals different length");
290 b1 = sshbuf_new();
291 b2 = sshbuf_new();
292 ASSERT_PTR_NE(b1, NULL);
293 ASSERT_PTR_NE(b2, NULL);
294 ASSERT_INT_EQ(sshbuf_put(b1, "hello", 5), 0);
295 ASSERT_INT_EQ(sshbuf_put(b2, "hell", 4), 0);
296 ASSERT_INT_EQ(sshbuf_equals(b1, b2), SSH_ERR_MESSAGE_INCOMPLETE);
297 sshbuf_free(b1);
298 sshbuf_free(b2);
299 TEST_DONE();
300
301 TEST_START("sshbuf_equals empty buffers");
302 b1 = sshbuf_new();
303 b2 = sshbuf_new();
304 ASSERT_PTR_NE(b1, NULL);
305 ASSERT_PTR_NE(b2, NULL);
306 ASSERT_INT_EQ(sshbuf_equals(b1, b2), 0);
307 sshbuf_free(b1);
308 sshbuf_free(b2);
309 TEST_DONE();
310
311 TEST_START("sshbuf_equals one empty buffer");
312 b1 = sshbuf_new();
313 b2 = sshbuf_new();
314 ASSERT_PTR_NE(b1, NULL);
315 ASSERT_PTR_NE(b2, NULL);
316 ASSERT_INT_EQ(sshbuf_put(b1, "hello", 5), 0);
317 ASSERT_INT_EQ(sshbuf_equals(b1, b2), SSH_ERR_MESSAGE_INCOMPLETE);
318 sshbuf_free(b1);
319 sshbuf_free(b2);
320 TEST_DONE();
321
322 TEST_START("sshbuf_equals buffer to self");
323 b1 = sshbuf_new();
324 ASSERT_PTR_NE(b1, NULL);
325 ASSERT_INT_EQ(sshbuf_put(b1, "hello", 5), 0);
326 ASSERT_INT_EQ(sshbuf_equals(b1, b1), 0);
327 sshbuf_free(b1);
328 TEST_DONE();
329 }
330
331 static void
332 test_sshbuf_dtourlb64(void)
333 {
334 struct sshbuf *b, *b64;
335 char *s;
336 /* From RFC4648 */
337 const u_char test_vec1[] = {0x14, 0xfb, 0x9c, 0x03, 0xd9, 0x7e};
338 const u_char test_vec2[] = {0xff, 0xff, 0xff};
339 const u_char test_vec3[] = {0xfb};
340
341 TEST_START("sshbuf_dtourlb64 empty");
342 b = sshbuf_new();
343 b64 = sshbuf_new();
344 ASSERT_PTR_NE(b, NULL);
345 ASSERT_PTR_NE(b64, NULL);
346 ASSERT_INT_EQ(sshbuf_dtourlb64(b, b64, 0), 0);
347 ASSERT_SIZE_T_EQ(sshbuf_len(b64), 0);
348 sshbuf_free(b);
349 sshbuf_free(b64);
350 TEST_DONE();
351
352 TEST_START("sshbuf_dtourlb64 no special chars");
353 b = sshbuf_new();
354 b64 = sshbuf_new();
355 ASSERT_PTR_NE(b, NULL);
356 ASSERT_PTR_NE(b64, NULL);
357 ASSERT_INT_EQ(sshbuf_put(b, "hello", 5), 0);
358 ASSERT_INT_EQ(sshbuf_dtourlb64(b, b64, 0), 0);
359 s = sshbuf_dup_string(b64);
360 ASSERT_PTR_NE(s, NULL);
361 ASSERT_STRING_EQ(s, "aGVsbG8");
362 free(s);
363 sshbuf_free(b);
364 sshbuf_free(b64);
365 TEST_DONE();
366
367 TEST_START("sshbuf_dtourlb64 with '+' char");
368 b = sshbuf_new();
369 b64 = sshbuf_new();
370 ASSERT_PTR_NE(b, NULL);
371 ASSERT_PTR_NE(b64, NULL);
372 ASSERT_INT_EQ(sshbuf_put(b, test_vec1, sizeof(test_vec1)), 0);
373 ASSERT_INT_EQ(sshbuf_dtourlb64(b, b64, 0), 0);
374 s = sshbuf_dup_string(b64);
375 ASSERT_PTR_NE(s, NULL);
376 ASSERT_STRING_EQ(s, "FPucA9l-");
377 free(s);
378 sshbuf_free(b);
379 sshbuf_free(b64);
380 TEST_DONE();
381
382 TEST_START("sshbuf_dtourlb64 with '/' char");
383 b = sshbuf_new();
384 b64 = sshbuf_new();
385 ASSERT_PTR_NE(b, NULL);
386 ASSERT_PTR_NE(b64, NULL);
387 ASSERT_INT_EQ(sshbuf_put(b, test_vec2, sizeof(test_vec2)), 0);
388 ASSERT_INT_EQ(sshbuf_dtourlb64(b, b64, 0), 0);
389 s = sshbuf_dup_string(b64);
390 ASSERT_PTR_NE(s, NULL);
391 ASSERT_STRING_EQ(s, "____");
392 free(s);
393 sshbuf_free(b);
394 sshbuf_free(b64);
395 TEST_DONE();
396
397 TEST_START("sshbuf_dtourlb64 with padding removed");
398 b = sshbuf_new();
399 b64 = sshbuf_new();
400 ASSERT_PTR_NE(b, NULL);
401 ASSERT_PTR_NE(b64, NULL);
402 ASSERT_INT_EQ(sshbuf_put(b, test_vec3, sizeof(test_vec3)), 0);
403 ASSERT_INT_EQ(sshbuf_dtourlb64(b, b64, 0), 0);
404 s = sshbuf_dup_string(b64);
405 ASSERT_PTR_NE(s, NULL);
406 ASSERT_STRING_EQ(s, "-w");
407 free(s);
408 sshbuf_free(b);
409 sshbuf_free(b64);
410 TEST_DONE();
411 }
412
413 void
414 sshbuf_misc_tests(void)
415 {
416 test_sshbuf_dump();
417 test_sshbuf_dtob16();
418 test_sshbuf_dtob64_string();
419 test_sshbuf_b64tod();
420 test_sshbuf_dup_string();
421 test_sshbuf_cmp();
422 test_sshbuf_find();
423 test_sshbuf_equals();
424 test_sshbuf_dtourlb64();
425 }
426