1 /* $OpenBSD: test_sshbuf_getput_basic.c,v 1.7 2026/03/06 06:57:33 dtucker 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 #include "ssherr.h"
18 #include "sshbuf.h"
19
20 void sshbuf_getput_basic_tests(void);
21
22 void
sshbuf_getput_basic_tests(void)23 sshbuf_getput_basic_tests(void)
24 {
25 struct sshbuf *p1, *p2;
26 const u_char *cd;
27 u_char *d, d2[32], x[] = {
28 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x00, 0x99
29 };
30 uint64_t v64;
31 uint32_t v32;
32 uint16_t v16;
33 u_char v8;
34 size_t s;
35 char *s2;
36 int r;
37 u_char bn1[] = { 0x00, 0x00, 0x00 };
38 u_char bn2[] = { 0x00, 0x00, 0x01, 0x02 };
39 u_char bn3[] = { 0x00, 0x80, 0x09 };
40 u_char bn_exp1[] = { 0x00, 0x00, 0x00, 0x00 };
41 u_char bn_exp2[] = { 0x00, 0x00, 0x00, 0x02, 0x01, 0x02 };
42 u_char bn_exp3[] = { 0x00, 0x00, 0x00, 0x03, 0x00, 0x80, 0x09 };
43
44 TEST_START("PEEK_U64");
45 ASSERT_U64_EQ(PEEK_U64(x), 0x1122334455667788ULL);
46 TEST_DONE();
47
48 TEST_START("PEEK_U32");
49 ASSERT_U32_EQ(PEEK_U32(x), 0x11223344);
50 TEST_DONE();
51
52 TEST_START("PEEK_U16");
53 ASSERT_U16_EQ(PEEK_U16(x), 0x1122);
54 TEST_DONE();
55
56 TEST_START("POKE_U64");
57 bzero(d2, sizeof(d2));
58 POKE_U64(d2, 0x1122334455667788ULL);
59 ASSERT_MEM_EQ(d2, x, 8);
60 TEST_DONE();
61
62 TEST_START("POKE_U32");
63 bzero(d2, sizeof(d2));
64 POKE_U32(d2, 0x11223344);
65 ASSERT_MEM_EQ(d2, x, 4);
66 TEST_DONE();
67
68 TEST_START("POKE_U16");
69 bzero(d2, sizeof(d2));
70 POKE_U16(d2, 0x1122);
71 ASSERT_MEM_EQ(d2, x, 2);
72 TEST_DONE();
73
74 TEST_START("sshbuf_put");
75 p1 = sshbuf_new();
76 ASSERT_PTR_NE(p1, NULL);
77 ASSERT_INT_EQ(sshbuf_put(p1, x, 5), 0);
78 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 5);
79 cd = sshbuf_ptr(p1);
80 ASSERT_PTR_NE(cd, NULL);
81 ASSERT_U8_EQ(cd[0], 0x11);
82 ASSERT_U8_EQ(cd[1], 0x22);
83 ASSERT_U8_EQ(cd[2], 0x33);
84 ASSERT_U8_EQ(cd[3], 0x44);
85 ASSERT_U8_EQ(cd[4], 0x55);
86 TEST_DONE();
87
88 TEST_START("sshbuf_get");
89 ASSERT_INT_EQ(sshbuf_get(p1, d2, 4), 0);
90 ASSERT_MEM_EQ(d2, x, 4);
91 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1);
92 ASSERT_U8_EQ(*(sshbuf_ptr(p1)), 0x55);
93 TEST_DONE();
94
95 TEST_START("sshbuf_get truncated");
96 r = sshbuf_get(p1, d2, 4);
97 ASSERT_INT_EQ(r, SSH_ERR_MESSAGE_INCOMPLETE);
98 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1);
99 ASSERT_U8_EQ(*(sshbuf_ptr(p1)), 0x55);
100 TEST_DONE();
101
102 TEST_START("sshbuf_put truncated");
103 ASSERT_INT_EQ(sshbuf_set_max_size(p1, 4), 0);
104 r = sshbuf_put(p1, x, 5);
105 ASSERT_INT_EQ(r, SSH_ERR_NO_BUFFER_SPACE);
106 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1);
107 sshbuf_free(p1);
108 TEST_DONE();
109
110 TEST_START("sshbuf_get_u64");
111 p1 = sshbuf_new();
112 ASSERT_PTR_NE(p1, NULL);
113 ASSERT_INT_EQ(sshbuf_put(p1, x, 10), 0);
114 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 10);
115 ASSERT_INT_EQ(sshbuf_get_u64(p1, &v64), 0);
116 ASSERT_U64_EQ(v64, 0x1122334455667788ULL);
117 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 2);
118 TEST_DONE();
119
120 TEST_START("sshbuf_get_u64 truncated");
121 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 2);
122 r = sshbuf_get_u64(p1, &v64);
123 ASSERT_INT_EQ(r, SSH_ERR_MESSAGE_INCOMPLETE);
124 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 2);
125 sshbuf_free(p1);
126 TEST_DONE();
127
128 TEST_START("sshbuf_get_u32");
129 p1 = sshbuf_new();
130 ASSERT_PTR_NE(p1, NULL);
131 ASSERT_INT_EQ(sshbuf_put(p1, x, 10), 0);
132 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 10);
133 ASSERT_INT_EQ(sshbuf_get_u32(p1, &v32), 0);
134 ASSERT_U32_EQ(v32, 0x11223344);
135 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 6);
136 ASSERT_INT_EQ(sshbuf_get_u32(p1, &v32), 0);
137 ASSERT_U32_EQ(v32, 0x55667788);
138 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 2);
139 TEST_DONE();
140
141 TEST_START("sshbuf_get_u32 truncated");
142 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 2);
143 r = sshbuf_get_u32(p1, &v32);
144 ASSERT_INT_EQ(r, SSH_ERR_MESSAGE_INCOMPLETE);
145 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 2);
146 sshbuf_free(p1);
147 TEST_DONE();
148
149 TEST_START("sshbuf_get_u16");
150 p1 = sshbuf_new();
151 ASSERT_PTR_NE(p1, NULL);
152 ASSERT_INT_EQ(sshbuf_put(p1, x, 9), 0);
153 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 9);
154 ASSERT_INT_EQ(sshbuf_get_u16(p1, &v16), 0);
155 ASSERT_U16_EQ(v16, 0x1122);
156 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 7);
157 ASSERT_INT_EQ(sshbuf_get_u16(p1, &v16), 0);
158 ASSERT_U16_EQ(v16, 0x3344);
159 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 5);
160 ASSERT_INT_EQ(sshbuf_get_u16(p1, &v16), 0);
161 ASSERT_U16_EQ(v16, 0x5566);
162 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 3);
163 ASSERT_INT_EQ(sshbuf_get_u16(p1, &v16), 0);
164 ASSERT_U16_EQ(v16, 0x7788);
165 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1);
166 TEST_DONE();
167
168 TEST_START("sshbuf_get_u16 truncated");
169 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1);
170 r = sshbuf_get_u16(p1, &v16);
171 ASSERT_INT_EQ(r, SSH_ERR_MESSAGE_INCOMPLETE);
172 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1);
173 sshbuf_free(p1);
174 TEST_DONE();
175
176 TEST_START("sshbuf_get_u8");
177 p1 = sshbuf_new();
178 ASSERT_PTR_NE(p1, NULL);
179 ASSERT_INT_EQ(sshbuf_put(p1, x, 2), 0);
180 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 2);
181 ASSERT_INT_EQ(sshbuf_get_u8(p1, &v8), 0);
182 ASSERT_U8_EQ(v8, 0x11);
183 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1);
184 ASSERT_INT_EQ(sshbuf_get_u8(p1, &v8), 0);
185 ASSERT_U8_EQ(v8, 0x22);
186 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0);
187 TEST_DONE();
188
189 TEST_START("sshbuf_get_u8 truncated");
190 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0);
191 r = sshbuf_get_u8(p1, &v8);
192 ASSERT_INT_EQ(r, SSH_ERR_MESSAGE_INCOMPLETE);
193 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0);
194 sshbuf_free(p1);
195 TEST_DONE();
196
197 TEST_START("sshbuf_put_u64");
198 p1 = sshbuf_new();
199 ASSERT_PTR_NE(p1, NULL);
200 ASSERT_INT_EQ(sshbuf_put_u64(p1, 0x1122334455667788ULL), 0);
201 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 8);
202 ASSERT_MEM_EQ(sshbuf_ptr(p1), x, 8);
203 sshbuf_free(p1);
204 TEST_DONE();
205
206 TEST_START("sshbuf_put_u64 exact");
207 p1 = sshbuf_new();
208 ASSERT_PTR_NE(p1, NULL);
209 ASSERT_INT_EQ(sshbuf_set_max_size(p1, 8), 0);
210 ASSERT_INT_EQ(sshbuf_put_u64(p1, 0x1122334455667788ULL), 0);
211 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 8);
212 ASSERT_MEM_EQ(sshbuf_ptr(p1), x, 8);
213 sshbuf_free(p1);
214 TEST_DONE();
215
216 TEST_START("sshbuf_put_u64 limited");
217 p1 = sshbuf_new();
218 ASSERT_PTR_NE(p1, NULL);
219 ASSERT_INT_EQ(sshbuf_set_max_size(p1, 7), 0);
220 r = sshbuf_put_u64(p1, 0x1122334455667788ULL);
221 ASSERT_INT_EQ(r, SSH_ERR_NO_BUFFER_SPACE);
222 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0);
223 sshbuf_free(p1);
224 TEST_DONE();
225
226 TEST_START("sshbuf_put_u32");
227 p1 = sshbuf_new();
228 ASSERT_PTR_NE(p1, NULL);
229 ASSERT_INT_EQ(sshbuf_put_u32(p1, 0x11223344), 0);
230 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 4);
231 ASSERT_MEM_EQ(sshbuf_ptr(p1), x, 4);
232 sshbuf_free(p1);
233 TEST_DONE();
234
235 TEST_START("sshbuf_put_u32 exact");
236 p1 = sshbuf_new();
237 ASSERT_PTR_NE(p1, NULL);
238 ASSERT_INT_EQ(sshbuf_set_max_size(p1, 4), 0);
239 ASSERT_INT_EQ(sshbuf_put_u32(p1, 0x11223344), 0);
240 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 4);
241 ASSERT_MEM_EQ(sshbuf_ptr(p1), x, 4);
242 sshbuf_free(p1);
243 TEST_DONE();
244
245 TEST_START("sshbuf_put_u32 limited");
246 p1 = sshbuf_new();
247 ASSERT_PTR_NE(p1, NULL);
248 ASSERT_INT_EQ(sshbuf_set_max_size(p1, 3), 0);
249 r = sshbuf_put_u32(p1, 0x11223344);
250 ASSERT_INT_EQ(r, SSH_ERR_NO_BUFFER_SPACE);
251 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0);
252 sshbuf_free(p1);
253 TEST_DONE();
254
255 TEST_START("sshbuf_put_u16");
256 p1 = sshbuf_new();
257 ASSERT_PTR_NE(p1, NULL);
258 ASSERT_INT_EQ(sshbuf_put_u16(p1, 0x1122), 0);
259 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 2);
260 ASSERT_MEM_EQ(sshbuf_ptr(p1), x, 2);
261 sshbuf_free(p1);
262 TEST_DONE();
263
264 TEST_START("sshbuf_put_u16");
265 p1 = sshbuf_new();
266 ASSERT_PTR_NE(p1, NULL);
267 ASSERT_INT_EQ(sshbuf_set_max_size(p1, 2), 0);
268 ASSERT_INT_EQ(sshbuf_put_u16(p1, 0x1122), 0);
269 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 2);
270 ASSERT_MEM_EQ(sshbuf_ptr(p1), x, 2);
271 sshbuf_free(p1);
272 TEST_DONE();
273
274 TEST_START("sshbuf_put_u16 limited");
275 p1 = sshbuf_new();
276 ASSERT_PTR_NE(p1, NULL);
277 ASSERT_INT_EQ(sshbuf_set_max_size(p1, 1), 0);
278 r = sshbuf_put_u16(p1, 0x1122);
279 ASSERT_INT_EQ(r, SSH_ERR_NO_BUFFER_SPACE);
280 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0);
281 sshbuf_free(p1);
282 TEST_DONE();
283
284 TEST_START("sshbuf_get_string");
285 p1 = sshbuf_new();
286 ASSERT_PTR_NE(p1, NULL);
287 ASSERT_INT_EQ(sshbuf_put_u32(p1, sizeof(x)), 0);
288 ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
289 ASSERT_INT_EQ(sshbuf_put_u32(p1, sizeof(x)), 0);
290 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(x) + 4 + 4);
291 ASSERT_INT_EQ(sshbuf_get_string(p1, &d, &s), 0);
292 ASSERT_SIZE_T_EQ(s, sizeof(x));
293 ASSERT_MEM_EQ(d, x, sizeof(x));
294 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 4);
295 free(d);
296 sshbuf_free(p1);
297 TEST_DONE();
298
299 TEST_START("sshbuf_get_string exact");
300 p1 = sshbuf_new();
301 ASSERT_PTR_NE(p1, NULL);
302 ASSERT_INT_EQ(sshbuf_set_max_size(p1, sizeof(x) + 4), 0);
303 ASSERT_INT_EQ(sshbuf_put_u32(p1, sizeof(x)), 0);
304 ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
305 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(x) + 4);
306 ASSERT_INT_EQ(sshbuf_get_string(p1, &d, &s), 0);
307 ASSERT_SIZE_T_EQ(s, sizeof(x));
308 ASSERT_MEM_EQ(d, x, sizeof(x));
309 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0);
310 free(d);
311 sshbuf_free(p1);
312 TEST_DONE();
313
314 TEST_START("sshbuf_get_string truncated");
315 p1 = sshbuf_new();
316 ASSERT_PTR_NE(p1, NULL);
317 ASSERT_INT_EQ(sshbuf_put_u32(p1, sizeof(x)), 0);
318 ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
319 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(x) + 4);
320 ASSERT_INT_EQ(sshbuf_consume_end(p1, 1), 0);
321 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(x) + 3);
322 r = sshbuf_get_string(p1, &d, &s);
323 ASSERT_INT_EQ(r, SSH_ERR_MESSAGE_INCOMPLETE);
324 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(x) + 3);
325 sshbuf_free(p1);
326 TEST_DONE();
327
328 TEST_START("sshbuf_get_string giant");
329 p1 = sshbuf_new();
330 ASSERT_PTR_NE(p1, NULL);
331 ASSERT_INT_EQ(sshbuf_put_u32(p1, 0xffffffff), 0);
332 ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
333 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(x) + 4);
334 r = sshbuf_get_string(p1, &d, &s);
335 ASSERT_INT_EQ(r, SSH_ERR_STRING_TOO_LARGE);
336 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(x) + 4);
337 sshbuf_free(p1);
338 TEST_DONE();
339
340 TEST_START("sshbuf_get_cstring giant");
341 p1 = sshbuf_new();
342 ASSERT_PTR_NE(p1, NULL);
343 ASSERT_INT_EQ(sshbuf_put_u32(p1, 0xffffffff), 0);
344 ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
345 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(x) + 4);
346 r = sshbuf_get_cstring(p1, &s2, &s);
347 ASSERT_INT_EQ(r, SSH_ERR_STRING_TOO_LARGE);
348 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(x) + 4);
349 sshbuf_free(p1);
350 TEST_DONE();
351
352 TEST_START("sshbuf_get_cstring embedded \\0");
353 p1 = sshbuf_new();
354 ASSERT_PTR_NE(p1, NULL);
355 ASSERT_INT_EQ(sshbuf_put_u32(p1, sizeof(x)), 0);
356 ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
357 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(x) + 4);
358 r = sshbuf_get_cstring(p1, &s2, NULL);
359 ASSERT_INT_EQ(r, SSH_ERR_INVALID_FORMAT);
360 sshbuf_free(p1);
361 TEST_DONE();
362
363 TEST_START("sshbuf_get_cstring trailing \\0");
364 p1 = sshbuf_new();
365 ASSERT_PTR_NE(p1, NULL);
366 ASSERT_INT_EQ(sshbuf_put_u32(p1, sizeof(x) - 1), 0);
367 ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x) - 1), 0);
368 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(x) + 4 - 1);
369 ASSERT_INT_EQ(sshbuf_get_cstring(p1, &s2, &s), 0);
370 ASSERT_SIZE_T_EQ(s, sizeof(x) - 1);
371 ASSERT_MEM_EQ(s2, x, s);
372 free(s2);
373 sshbuf_free(p1);
374 TEST_DONE();
375
376 TEST_START("sshbuf_put_string");
377 p1 = sshbuf_new();
378 ASSERT_PTR_NE(p1, NULL);
379 ASSERT_INT_EQ(sshbuf_put_string(p1, x, sizeof(x)), 0);
380 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(x) + 4);
381 ASSERT_U32_EQ(PEEK_U32(sshbuf_ptr(p1)), sizeof(x));
382 ASSERT_MEM_EQ(sshbuf_ptr(p1) + 4, x, sizeof(x));
383 sshbuf_free(p1);
384 TEST_DONE();
385
386 TEST_START("sshbuf_put_string limited");
387 p1 = sshbuf_new();
388 ASSERT_PTR_NE(p1, NULL);
389 ASSERT_INT_EQ(sshbuf_set_max_size(p1, sizeof(x) + 4 - 1), 0);
390 r = sshbuf_put_string(p1, x, sizeof(x));
391 ASSERT_INT_EQ(r, SSH_ERR_NO_BUFFER_SPACE);
392 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0);
393 sshbuf_free(p1);
394 TEST_DONE();
395
396 TEST_START("sshbuf_put_string giant");
397 p1 = sshbuf_new();
398 ASSERT_PTR_NE(p1, NULL);
399 r = sshbuf_put_string(p1, (void *)0x01, 0xfffffffc);
400 ASSERT_INT_EQ(r, SSH_ERR_NO_BUFFER_SPACE);
401 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0);
402 sshbuf_free(p1);
403 TEST_DONE();
404
405 TEST_START("sshbuf_putf");
406 p1 = sshbuf_new();
407 ASSERT_PTR_NE(p1, NULL);
408 r = sshbuf_putf(p1, "%s %d %x", "hello", 23, 0x5f);
409 ASSERT_INT_EQ(r, 0);
410 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 11);
411 ASSERT_MEM_EQ(sshbuf_ptr(p1), "hello 23 5f", 11);
412 sshbuf_free(p1);
413 TEST_DONE();
414
415 TEST_START("sshbuf_putb");
416 p1 = sshbuf_new();
417 ASSERT_PTR_NE(p1, NULL);
418 p2 = sshbuf_new();
419 ASSERT_PTR_NE(p2, NULL);
420 ASSERT_INT_EQ(sshbuf_put(p1, "blahblahblah", 12), 0);
421 ASSERT_INT_EQ(sshbuf_putb(p2, p1), 0);
422 sshbuf_free(p1);
423 ASSERT_SIZE_T_EQ(sshbuf_len(p2), 12);
424 ASSERT_MEM_EQ(sshbuf_ptr(p2), "blahblahblah", 12);
425 sshbuf_free(p2);
426 TEST_DONE();
427
428 TEST_START("sshbuf_put_bignum2_bytes empty buf");
429 p1 = sshbuf_new();
430 ASSERT_PTR_NE(p1, NULL);
431 ASSERT_INT_EQ(sshbuf_put_bignum2_bytes(p1, NULL, 0), 0);
432 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(bn_exp1));
433 ASSERT_MEM_EQ(sshbuf_ptr(p1), bn_exp1, sizeof(bn_exp1));
434 sshbuf_free(p1);
435 TEST_DONE();
436
437 TEST_START("sshbuf_put_bignum2_bytes all zeroes");
438 p1 = sshbuf_new();
439 ASSERT_PTR_NE(p1, NULL);
440 ASSERT_INT_EQ(sshbuf_put_bignum2_bytes(p1, bn1, sizeof(bn1)), 0);
441 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(bn_exp1));
442 ASSERT_MEM_EQ(sshbuf_ptr(p1), bn_exp1, sizeof(bn_exp1));
443 sshbuf_free(p1);
444 TEST_DONE();
445
446 TEST_START("sshbuf_put_bignum2_bytes simple");
447 p1 = sshbuf_new();
448 ASSERT_PTR_NE(p1, NULL);
449 ASSERT_INT_EQ(sshbuf_put_bignum2_bytes(p1, bn2+2, sizeof(bn2)-2), 0);
450 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(bn_exp2));
451 ASSERT_MEM_EQ(sshbuf_ptr(p1), bn_exp2, sizeof(bn_exp2));
452 sshbuf_free(p1);
453 TEST_DONE();
454
455 TEST_START("sshbuf_put_bignum2_bytes leading zero");
456 p1 = sshbuf_new();
457 ASSERT_PTR_NE(p1, NULL);
458 ASSERT_INT_EQ(sshbuf_put_bignum2_bytes(p1, bn2, sizeof(bn2)), 0);
459 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(bn_exp2));
460 ASSERT_MEM_EQ(sshbuf_ptr(p1), bn_exp2, sizeof(bn_exp2));
461 sshbuf_free(p1);
462 TEST_DONE();
463
464 TEST_START("sshbuf_put_bignum2_bytes neg");
465 p1 = sshbuf_new();
466 ASSERT_PTR_NE(p1, NULL);
467 ASSERT_INT_EQ(sshbuf_put_bignum2_bytes(p1, bn3+1, sizeof(bn3)-1), 0);
468 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(bn_exp3));
469 ASSERT_MEM_EQ(sshbuf_ptr(p1), bn_exp3, sizeof(bn_exp3));
470 sshbuf_free(p1);
471 TEST_DONE();
472
473 TEST_START("sshbuf_put_bignum2_bytes neg and leading zero");
474 p1 = sshbuf_new();
475 ASSERT_PTR_NE(p1, NULL);
476 ASSERT_INT_EQ(sshbuf_put_bignum2_bytes(p1, bn3, sizeof(bn3)), 0);
477 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sizeof(bn_exp3));
478 ASSERT_MEM_EQ(sshbuf_ptr(p1), bn_exp3, sizeof(bn_exp3));
479 sshbuf_free(p1);
480 TEST_DONE();
481
482 TEST_START("sshbuf_peek_u64");
483 p1 = sshbuf_new();
484 ASSERT_PTR_NE(p1, NULL);
485 ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
486 ASSERT_INT_EQ(sshbuf_peek_u64(p1, 0, &v64), 0);
487 ASSERT_U64_EQ(v64, 0x1122334455667788ULL);
488 ASSERT_INT_EQ(sshbuf_peek_u64(p1, 2, &v64), 0);
489 ASSERT_U64_EQ(v64, 0x3344556677880099ULL);
490 ASSERT_INT_EQ(sshbuf_peek_u64(p1, 3, &v64), SSH_ERR_MESSAGE_INCOMPLETE);
491 ASSERT_INT_EQ(sshbuf_peek_u64(p1, sizeof(x), &v64),
492 SSH_ERR_MESSAGE_INCOMPLETE);
493 ASSERT_INT_EQ(sshbuf_peek_u64(p1, 1000, &v64),
494 SSH_ERR_MESSAGE_INCOMPLETE);
495 sshbuf_free(p1);
496 TEST_DONE();
497
498 TEST_START("sshbuf_peek_u32");
499 p1 = sshbuf_new();
500 ASSERT_PTR_NE(p1, NULL);
501 ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
502 ASSERT_INT_EQ(sshbuf_peek_u32(p1, 0, &v32), 0);
503 ASSERT_U32_EQ(v32, 0x11223344);
504 ASSERT_INT_EQ(sshbuf_peek_u32(p1, 6, &v32), 0);
505 ASSERT_U32_EQ(v32, 0x77880099);
506 ASSERT_INT_EQ(sshbuf_peek_u32(p1, 7, &v32), SSH_ERR_MESSAGE_INCOMPLETE);
507 ASSERT_INT_EQ(sshbuf_peek_u32(p1, sizeof(x), &v32),
508 SSH_ERR_MESSAGE_INCOMPLETE);
509 ASSERT_INT_EQ(sshbuf_peek_u32(p1, 1000, &v32),
510 SSH_ERR_MESSAGE_INCOMPLETE);
511 sshbuf_free(p1);
512 TEST_DONE();
513
514 TEST_START("sshbuf_peek_u16");
515 p1 = sshbuf_new();
516 ASSERT_PTR_NE(p1, NULL);
517 ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
518 ASSERT_INT_EQ(sshbuf_peek_u16(p1, 0, &v16), 0);
519 ASSERT_U16_EQ(v16, 0x1122);
520 ASSERT_INT_EQ(sshbuf_peek_u16(p1, 8, &v16), 0);
521 ASSERT_U16_EQ(v16, 0x99);
522 ASSERT_INT_EQ(sshbuf_peek_u16(p1, 9, &v16), SSH_ERR_MESSAGE_INCOMPLETE);
523 ASSERT_INT_EQ(sshbuf_peek_u16(p1, sizeof(x), &v16),
524 SSH_ERR_MESSAGE_INCOMPLETE);
525 ASSERT_INT_EQ(sshbuf_peek_u16(p1, 1000, &v16),
526 SSH_ERR_MESSAGE_INCOMPLETE);
527 sshbuf_free(p1);
528 TEST_DONE();
529
530 TEST_START("sshbuf_peek_u8");
531 p1 = sshbuf_new();
532 ASSERT_PTR_NE(p1, NULL);
533 ASSERT_INT_EQ(sshbuf_put(p1, x, sizeof(x)), 0);
534 ASSERT_INT_EQ(sshbuf_peek_u8(p1, 0, &v8), 0);
535 ASSERT_U8_EQ(v8, 0x11);
536 ASSERT_INT_EQ(sshbuf_peek_u8(p1, 9, &v8), 0);
537 ASSERT_U8_EQ(v8, 0x99);
538 ASSERT_INT_EQ(sshbuf_peek_u8(p1, sizeof(x), &v8),
539 SSH_ERR_MESSAGE_INCOMPLETE);
540 ASSERT_INT_EQ(sshbuf_peek_u8(p1, 1000, &v8),
541 SSH_ERR_MESSAGE_INCOMPLETE);
542 sshbuf_free(p1);
543 TEST_DONE();
544
545 TEST_START("sshbuf_poke_u64");
546 p1 = sshbuf_new();
547 ASSERT_PTR_NE(p1, NULL);
548 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
549 /* poke at start of buffer */
550 ASSERT_INT_EQ(sshbuf_poke_u64(p1, 0, 0xa1b2c3d4e5f60718ULL), 0);
551 s2 = sshbuf_dtob16(p1);
552 ASSERT_PTR_NE(s2, NULL);
553 ASSERT_STRING_EQ(s2, "a1b2c3d4e5f607180000");
554 free(s2);
555 sshbuf_reset(p1);
556 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
557 /* poke aligned with end of buffer */
558 ASSERT_INT_EQ(sshbuf_poke_u64(p1, 2, 0xa1b2c3d4e5f60718ULL), 0);
559 s2 = sshbuf_dtob16(p1);
560 ASSERT_PTR_NE(s2, NULL);
561 ASSERT_STRING_EQ(s2, "0000a1b2c3d4e5f60718");
562 free(s2);
563 sshbuf_reset(p1);
564 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
565 /* poke past end of buffer */
566 ASSERT_INT_EQ(sshbuf_poke_u64(p1, 3, 0xa1b2c3d4e5f60718ULL),
567 SSH_ERR_NO_BUFFER_SPACE);
568 ASSERT_INT_EQ(sshbuf_poke_u64(p1, 10, 0xa1b2c3d4e5f60718ULL),
569 SSH_ERR_NO_BUFFER_SPACE);
570 ASSERT_INT_EQ(sshbuf_poke_u64(p1, 1000, 0xa1b2c3d4e5f60718ULL),
571 SSH_ERR_NO_BUFFER_SPACE);
572 /* ensure failed pokes do not modify buffer */
573 s2 = sshbuf_dtob16(p1);
574 ASSERT_PTR_NE(s2, NULL);
575 ASSERT_STRING_EQ(s2, "00000000000000000000");
576 sshbuf_free(p1);
577 free(s2);
578 TEST_DONE();
579
580 TEST_START("sshbuf_poke_u32");
581 p1 = sshbuf_new();
582 ASSERT_PTR_NE(p1, NULL);
583 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
584 /* poke at start of buffer */
585 ASSERT_INT_EQ(sshbuf_poke_u32(p1, 0, 0xa1b2c3d4), 0);
586 s2 = sshbuf_dtob16(p1);
587 ASSERT_PTR_NE(s2, NULL);
588 ASSERT_STRING_EQ(s2, "a1b2c3d4000000000000");
589 free(s2);
590 sshbuf_reset(p1);
591 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
592 /* poke aligned with end of buffer */
593 ASSERT_INT_EQ(sshbuf_poke_u32(p1, 6, 0xa1b2c3d4), 0);
594 s2 = sshbuf_dtob16(p1);
595 ASSERT_PTR_NE(s2, NULL);
596 ASSERT_STRING_EQ(s2, "000000000000a1b2c3d4");
597 free(s2);
598 sshbuf_reset(p1);
599 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
600 /* poke past end of buffer */
601 ASSERT_INT_EQ(sshbuf_poke_u32(p1, 7, 0xa1b2c3d4),
602 SSH_ERR_NO_BUFFER_SPACE);
603 ASSERT_INT_EQ(sshbuf_poke_u32(p1, 10, 0xa1b2c3d4),
604 SSH_ERR_NO_BUFFER_SPACE);
605 ASSERT_INT_EQ(sshbuf_poke_u32(p1, 1000, 0xa1b2c3d4),
606 SSH_ERR_NO_BUFFER_SPACE);
607 /* ensure failed pokes do not modify buffer */
608 s2 = sshbuf_dtob16(p1);
609 ASSERT_PTR_NE(s2, NULL);
610 ASSERT_STRING_EQ(s2, "00000000000000000000");
611 sshbuf_free(p1);
612 free(s2);
613 TEST_DONE();
614
615 TEST_START("sshbuf_poke_u16");
616 p1 = sshbuf_new();
617 ASSERT_PTR_NE(p1, NULL);
618 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
619 /* poke at start of buffer */
620 ASSERT_INT_EQ(sshbuf_poke_u16(p1, 0, 0xa1b2), 0);
621 s2 = sshbuf_dtob16(p1);
622 ASSERT_PTR_NE(s2, NULL);
623 ASSERT_STRING_EQ(s2, "a1b20000000000000000");
624 free(s2);
625 sshbuf_reset(p1);
626 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
627 /* poke aligned with end of buffer */
628 ASSERT_INT_EQ(sshbuf_poke_u16(p1, 8, 0xa1b2), 0);
629 s2 = sshbuf_dtob16(p1);
630 ASSERT_PTR_NE(s2, NULL);
631 ASSERT_STRING_EQ(s2, "0000000000000000a1b2");
632 free(s2);
633 sshbuf_reset(p1);
634 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
635 /* poke past end of buffer */
636 ASSERT_INT_EQ(sshbuf_poke_u16(p1, 9, 0xa1b2),
637 SSH_ERR_NO_BUFFER_SPACE);
638 ASSERT_INT_EQ(sshbuf_poke_u16(p1, 10, 0xa1b2),
639 SSH_ERR_NO_BUFFER_SPACE);
640 ASSERT_INT_EQ(sshbuf_poke_u16(p1, 1000, 0xa1b2),
641 SSH_ERR_NO_BUFFER_SPACE);
642 /* ensure failed pokes do not modify buffer */
643 s2 = sshbuf_dtob16(p1);
644 ASSERT_PTR_NE(s2, NULL);
645 ASSERT_STRING_EQ(s2, "00000000000000000000");
646 sshbuf_free(p1);
647 free(s2);
648 TEST_DONE();
649
650 TEST_START("sshbuf_poke_u8");
651 p1 = sshbuf_new();
652 ASSERT_PTR_NE(p1, NULL);
653 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
654 /* poke at start of buffer */
655 ASSERT_INT_EQ(sshbuf_poke_u8(p1, 0, 0xa1), 0);
656 s2 = sshbuf_dtob16(p1);
657 ASSERT_PTR_NE(s2, NULL);
658 ASSERT_STRING_EQ(s2, "a1000000000000000000");
659 free(s2);
660 sshbuf_reset(p1);
661 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
662 /* poke aligned with end of buffer */
663 ASSERT_INT_EQ(sshbuf_poke_u8(p1, 9, 0xa1), 0);
664 s2 = sshbuf_dtob16(p1);
665 ASSERT_PTR_NE(s2, NULL);
666 ASSERT_STRING_EQ(s2, "000000000000000000a1");
667 free(s2);
668 sshbuf_reset(p1);
669 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
670 /* poke past end of buffer */
671 ASSERT_INT_EQ(sshbuf_poke_u8(p1, 10, 0xa1), SSH_ERR_NO_BUFFER_SPACE);
672 ASSERT_INT_EQ(sshbuf_poke_u8(p1, 1000, 0xa1), SSH_ERR_NO_BUFFER_SPACE);
673 /* ensure failed pokes do not modify buffer */
674 s2 = sshbuf_dtob16(p1);
675 ASSERT_PTR_NE(s2, NULL);
676 ASSERT_STRING_EQ(s2, "00000000000000000000");
677 sshbuf_free(p1);
678 free(s2);
679 TEST_DONE();
680
681 TEST_START("sshbuf_poke");
682 p1 = sshbuf_new();
683 ASSERT_PTR_NE(p1, NULL);
684 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
685 /* poke at start of buffer */
686 ASSERT_INT_EQ(sshbuf_poke(p1, 0, "hello!", 6), 0);
687 s2 = sshbuf_dtob16(p1);
688 ASSERT_PTR_NE(s2, NULL);
689 ASSERT_STRING_EQ(s2, "68656c6c6f2100000000");
690 free(s2);
691 sshbuf_reset(p1);
692 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
693 /* poke aligned with end of buffer */
694 ASSERT_INT_EQ(sshbuf_poke(p1, 4, "hello!", 6), 0);
695 s2 = sshbuf_dtob16(p1);
696 ASSERT_PTR_NE(s2, NULL);
697 ASSERT_STRING_EQ(s2, "0000000068656c6c6f21");
698 free(s2);
699 sshbuf_reset(p1);
700 ASSERT_INT_EQ(sshbuf_reserve(p1, 10, NULL), 0);
701 /* poke past end of buffer */
702 ASSERT_INT_EQ(sshbuf_poke(p1, 7, "hello!", 6),
703 SSH_ERR_NO_BUFFER_SPACE);
704 ASSERT_INT_EQ(sshbuf_poke(p1, 10, "hello!", 6),
705 SSH_ERR_NO_BUFFER_SPACE);
706 ASSERT_INT_EQ(sshbuf_poke(p1, 1000, "hello!", 6),
707 SSH_ERR_NO_BUFFER_SPACE);
708 /* ensure failed pokes do not modify buffer */
709 s2 = sshbuf_dtob16(p1);
710 ASSERT_PTR_NE(s2, NULL);
711 ASSERT_STRING_EQ(s2, "00000000000000000000");
712 sshbuf_free(p1);
713 free(s2);
714 TEST_DONE();
715
716 TEST_START("sshbuf_get_nulterminated_string");
717 p1 = sshbuf_new();
718 ASSERT_PTR_NE(p1, NULL);
719 ASSERT_INT_EQ(sshbuf_put(p1, "hello", 5), 0);
720 ASSERT_INT_EQ(sshbuf_put_u8(p1, 0), 0); /* hello\0 */
721 ASSERT_INT_EQ(sshbuf_put(p1, "there", 5), 0); /* hello\0there */
722 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 11);
723 /* short maxlen */
724 ASSERT_INT_EQ(sshbuf_get_nulterminated_string(p1, 1, &s2, &s),
725 SSH_ERR_INVALID_FORMAT);
726 ASSERT_PTR_EQ(s2, NULL);
727 ASSERT_SIZE_T_EQ(s, 0);
728 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 11); /* Buffer should be unchanged */
729 ASSERT_INT_EQ(sshbuf_get_nulterminated_string(p1, 4, &s2, &s),
730 SSH_ERR_INVALID_FORMAT);
731 ASSERT_PTR_EQ(s2, NULL);
732 ASSERT_SIZE_T_EQ(s, 0);
733 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 11); /* Buffer should be unchanged */
734 /* minimum usable maxlen */
735 ASSERT_INT_EQ(sshbuf_get_nulterminated_string(p1, 5, &s2, &s), 0);
736 ASSERT_STRING_EQ(s2, "hello");
737 ASSERT_SIZE_T_EQ(s, 5);
738 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 5); /* "there" remains */
739 free(s2);
740 sshbuf_free(p1);
741 TEST_DONE();
742
743 TEST_START("sshbuf_get_nulterminated_string un-terminated string");
744 p1 = sshbuf_new();
745 ASSERT_PTR_NE(p1, NULL);
746 ASSERT_INT_EQ(sshbuf_put(p1, "there", 5), 0); /* "there" */
747 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 5);
748 ASSERT_INT_EQ(sshbuf_get_nulterminated_string(p1, 5, &s2, &s),
749 SSH_ERR_INVALID_FORMAT);
750 ASSERT_PTR_EQ(s2, NULL);
751 ASSERT_SIZE_T_EQ(s, 0);
752 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 5); /* Buffer should be unchanged */
753 ASSERT_INT_EQ(sshbuf_get_nulterminated_string(p1, 6, &s2, &s),
754 SSH_ERR_MESSAGE_INCOMPLETE);
755 ASSERT_PTR_EQ(s2, NULL);
756 ASSERT_SIZE_T_EQ(s, 0);
757 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 5); /* Buffer should be unchanged */
758 ASSERT_INT_EQ(sshbuf_get_nulterminated_string(p1, SIZE_MAX, &s2, &s),
759 SSH_ERR_MESSAGE_INCOMPLETE);
760 ASSERT_PTR_EQ(s2, NULL);
761 ASSERT_SIZE_T_EQ(s, 0);
762 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 5);
763 sshbuf_free(p1);
764 TEST_DONE();
765
766 TEST_START("sshbuf_get_nulterminated_string subsequent strings");
767 p1 = sshbuf_new();
768 ASSERT_PTR_NE(p1, NULL);
769 ASSERT_INT_EQ(sshbuf_put(p1, "there", 5), 0);
770 ASSERT_INT_EQ(sshbuf_put_u8(p1, 0), 0); /* "there\0" */
771 ASSERT_INT_EQ(sshbuf_put(p1, "it is", 5), 0);
772 ASSERT_INT_EQ(sshbuf_put_u8(p1, 0), 0); /* "it is\0" */
773 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 12);
774 ASSERT_INT_EQ(sshbuf_get_nulterminated_string(p1, 6, &s2, &s), 0);
775 ASSERT_STRING_EQ(s2, "there");
776 ASSERT_SIZE_T_EQ(s, 5);
777 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 6);
778 free(s2);
779 ASSERT_INT_EQ(sshbuf_get_nulterminated_string(p1, SIZE_MAX, &s2, &s), 0);
780 ASSERT_STRING_EQ(s2, "it is");
781 ASSERT_SIZE_T_EQ(s, 5);
782 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0);
783 free(s2);
784 sshbuf_free(p1);
785 TEST_DONE();
786
787 TEST_START("sshbuf_get_nulterminated_string empty buffer");
788 p1 = sshbuf_new();
789 ASSERT_PTR_NE(p1, NULL);
790 ASSERT_INT_EQ(sshbuf_get_nulterminated_string(p1, SIZE_MAX, &s2, &s),
791 SSH_ERR_MESSAGE_INCOMPLETE);
792 ASSERT_PTR_EQ(s2, NULL);
793 ASSERT_SIZE_T_EQ(s, 0);
794 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0);
795 sshbuf_free(p1);
796 TEST_DONE();
797
798 TEST_START("sshbuf_get_nulterminated_string: single nul byte");
799 p1 = sshbuf_new();
800 ASSERT_PTR_NE(p1, NULL);
801 ASSERT_INT_EQ(sshbuf_put_u8(p1, 0), 0);
802 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 1);
803 ASSERT_INT_EQ(sshbuf_get_nulterminated_string(p1, 0, &s2, &s), 0);
804 ASSERT_STRING_EQ(s2, "");
805 ASSERT_SIZE_T_EQ(s, 0);
806 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0);
807 free(s2);
808 sshbuf_free(p1);
809 TEST_DONE();
810
811 TEST_START("sshbuf_get_nulterminated_string starts with nul");
812 p1 = sshbuf_new();
813 ASSERT_PTR_NE(p1, NULL);
814 ASSERT_INT_EQ(sshbuf_put_u8(p1, 0), 0);
815 ASSERT_INT_EQ(sshbuf_put(p1, "hello", 5), 0);
816 ASSERT_INT_EQ(sshbuf_put_u8(p1, 0), 0);
817 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 7);
818 ASSERT_INT_EQ(sshbuf_get_nulterminated_string(p1, SIZE_MAX, &s2, &s), 0);
819 ASSERT_STRING_EQ(s2, "");
820 ASSERT_SIZE_T_EQ(s, 0);
821 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 6);
822 free(s2);
823 ASSERT_INT_EQ(sshbuf_get_nulterminated_string(p1, SIZE_MAX, &s2, &s), 0);
824 ASSERT_STRING_EQ(s2, "hello");
825 ASSERT_SIZE_T_EQ(s, 5);
826 ASSERT_SIZE_T_EQ(sshbuf_len(p1), 0);
827 free(s2);
828 sshbuf_free(p1);
829 TEST_DONE();
830 }
831