Debian Codegraph @

regress/unittests/sshbuf/test_sshbuf_fuzz.c

raw
1 /* $OpenBSD: test_sshbuf_fuzz.c,v 1.5 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
18 #include "ssherr.h"
19 #include "sshbuf.h"
20
21 #define NUM_FUZZ_TESTS (1 << 18)
22
23 void sshbuf_fuzz_tests(void);
24
25 void
26 sshbuf_fuzz_tests(void)
27 {
28 struct sshbuf *p1;
29 u_char *dp;
30 size_t sz, sz2, i, ntests = NUM_FUZZ_TESTS;
31 uint32_t r;
32 int ret;
33
34 if (test_is_fast())
35 ntests >>= 2;
36 if (test_is_slow())
37 ntests <<= 2;
38
39 /* NB. uses sshbuf internals */
40 TEST_START("fuzz alloc/dealloc");
41 p1 = sshbuf_new();
42 ASSERT_INT_EQ(sshbuf_set_max_size(p1, 16 * 1024), 0);
43 ASSERT_PTR_NE(p1, NULL);
44 ASSERT_PTR_NE(sshbuf_ptr(p1), NULL);
45 ASSERT_MEM_ZERO_NE(sshbuf_ptr(p1), sshbuf_len(p1));
46 for (i = 0; i < ntests; i++) {
47 r = arc4random_uniform(10);
48 if (r == 0) {
49 /* 10% chance: small reserve */
50 r = arc4random_uniform(10);
51 fuzz_reserve:
52 sz = sshbuf_avail(p1);
53 sz2 = sshbuf_len(p1);
54 ret = sshbuf_reserve(p1, r, &dp);
55 if (ret < 0) {
56 ASSERT_PTR_EQ(dp, NULL);
57 ASSERT_SIZE_T_LT(sz, r);
58 ASSERT_SIZE_T_EQ(sshbuf_avail(p1), sz);
59 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sz2);
60 } else {
61 ASSERT_PTR_NE(dp, NULL);
62 ASSERT_SIZE_T_GE(sz, r);
63 ASSERT_SIZE_T_EQ(sshbuf_avail(p1), sz - r);
64 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sz2 + r);
65 memset(dp, arc4random_uniform(255) + 1, r);
66 }
67 } else if (r < 3) {
68 /* 20% chance: big reserve */
69 r = arc4random_uniform(8 * 1024);
70 goto fuzz_reserve;
71 } else if (r == 3) {
72 /* 10% chance: small consume */
73 r = arc4random_uniform(10);
74 fuzz_consume:
75 sz = sshbuf_avail(p1);
76 sz2 = sshbuf_len(p1);
77 /* 50% change consume from end, otherwise start */
78 ret = ((arc4random() & 1) ?
79 sshbuf_consume : sshbuf_consume_end)(p1, r);
80 if (ret < 0) {
81 ASSERT_SIZE_T_LT(sz2, r);
82 ASSERT_SIZE_T_EQ(sshbuf_avail(p1), sz);
83 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sz2);
84 } else {
85 ASSERT_SIZE_T_GE(sz2, r);
86 ASSERT_SIZE_T_EQ(sshbuf_avail(p1), sz + r);
87 ASSERT_SIZE_T_EQ(sshbuf_len(p1), sz2 - r);
88 }
89 } else if (r < 8) {
90 /* 40% chance: big consume */
91 r = arc4random_uniform(2 * 1024);
92 goto fuzz_consume;
93 } else if (r == 8) {
94 /* 10% chance: reset max size */
95 r = arc4random_uniform(16 * 1024);
96 sz = sshbuf_max_size(p1);
97 if (sshbuf_set_max_size(p1, r) < 0)
98 ASSERT_SIZE_T_EQ(sshbuf_max_size(p1), sz);
99 else
100 ASSERT_SIZE_T_EQ(sshbuf_max_size(p1), r);
101 } else {
102 if (arc4random_uniform(8192) == 0) {
103 /* tiny chance: new buffer */
104 ASSERT_PTR_NE(sshbuf_ptr(p1), NULL);
105 ASSERT_MEM_ZERO_NE(sshbuf_ptr(p1), sshbuf_len(p1));
106 sshbuf_free(p1);
107 p1 = sshbuf_new();
108 ASSERT_PTR_NE(p1, NULL);
109 ASSERT_INT_EQ(sshbuf_set_max_size(p1,
110 16 * 1024), 0);
111 } else {
112 /* Almost 10%: giant reserve */
113 /* use arc4random_buf for r > 2^32 on 64 bit */
114 arc4random_buf(&r, sizeof(r));
115 while (r < SSHBUF_SIZE_MAX / 2) {
116 r <<= 1;
117 r |= arc4random() & 1;
118 }
119 goto fuzz_reserve;
120 }
121 }
122 ASSERT_PTR_NE(sshbuf_ptr(p1), NULL);
123 ASSERT_SIZE_T_LE(sshbuf_max_size(p1), 16 * 1024);
124 }
125 ASSERT_PTR_NE(sshbuf_ptr(p1), NULL);
126 ASSERT_MEM_ZERO_NE(sshbuf_ptr(p1), sshbuf_len(p1));
127 sshbuf_free(p1);
128 TEST_DONE();
129 }