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 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