5454043422

Committed 04 Jul 2023 11:13AM CUT coverage: 91.659% (-0.07%) from 91.732%

Build # 5454043422

Build Type

Pull #3609

github

Committed by

web-flow

Commit Message

Merge 5741e183c into cf8d8a6ca

Pull Request Pull Request #3609: [TLS 1.3] Hybrid PQ/T key establishment

Run Details

78635 of 85791 relevant lines covered (91.66%)

12300857.61 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.65

/src/fuzzer/mode_padding.cpp

/*
* (C) 2018 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include "fuzzers.h"

#include <botan/internal/mode_pad.h>
#include <botan/internal/tls_cbc.h>

namespace {

size_t ref_pkcs7_unpad(const uint8_t in[], size_t len) {
   if(len <= 2) {
      return len;
   }

   const size_t padding_length = in[len - 1];

   if(padding_length == 0 || padding_length > len) {
      return len;
   }

   const size_t padding_start = len - padding_length;

   for(size_t i = padding_start; i != len; ++i) {
      if(in[i] != padding_length) {
         return len;
      }
   }

   return len - padding_length;
}

size_t ref_x923_unpad(const uint8_t in[], size_t len) {
   if(len <= 2) {
      return len;
   }

   const size_t padding_length = in[len - 1];

   if(padding_length == 0 || padding_length > len) {
      return len;
   }
   const size_t padding_start = len - padding_length;

   for(size_t i = padding_start; i != len - 1; ++i) {
      if(in[i] != 0) {
         return len;
      }
   }

   return len - padding_length;
}

size_t ref_oneandzero_unpad(const uint8_t in[], size_t len) {
   if(len <= 2) {
      return len;
   }

   size_t idx = len - 1;

   for(;;) {
      if(in[idx] == 0) {
         if(idx == 0) {
            return len;
         }
         idx -= 1;
         continue;
      } else if(in[idx] == 0x80) {
         return idx;
      } else {
         return len;
      }
   }

   return len;
}

size_t ref_esp_unpad(const uint8_t in[], size_t len) {
   if(len <= 2) {
      return len;
   }

   const size_t padding_bytes = in[len - 1];

   if(padding_bytes == 0 || padding_bytes > len) {
      return len;
   }

   const size_t padding_start = len - padding_bytes;
   for(size_t i = padding_start; i != len; ++i) {
      if(in[i] != (i - padding_start + 1)) {
         return len;
      }
   }

   return len - padding_bytes;
}

uint16_t ref_tls_cbc_unpad(const uint8_t in[], size_t len) {
   if(len == 0) {
      return 0;
   }

   const size_t padding_length = in[(len - 1)];

   if(padding_length >= len) {
      return 0;
   }

   /*
   * TLS v1.0 and up require all the padding bytes be the same value
   * and allows up to 255 bytes.
   */
   for(size_t i = 0; i != 1 + padding_length; ++i) {
      if(in[(len - i - 1)] != padding_length) {
         return 0;
      }
   }
   return padding_length + 1;
}

}  // namespace

void fuzz(const uint8_t in[], size_t len) {
   static Botan::PKCS7_Padding pkcs7;
   static Botan::ANSI_X923_Padding x923;
   static Botan::OneAndZeros_Padding oneandzero;
   static Botan::ESP_Padding esp;

   if(pkcs7.valid_blocksize(len)) {
      const size_t ct_pkcs7 = pkcs7.unpad(in, len);
      const size_t ref_pkcs7 = ref_pkcs7_unpad(in, len);
      FUZZER_ASSERT_EQUAL(ct_pkcs7, ref_pkcs7);
   }

   if(x923.valid_blocksize(len)) {
      const size_t ct_x923 = x923.unpad(in, len);
      const size_t ref_x923 = ref_x923_unpad(in, len);
      FUZZER_ASSERT_EQUAL(ct_x923, ref_x923);
   }

   if(oneandzero.valid_blocksize(len)) {
      const size_t ct_oneandzero = oneandzero.unpad(in, len);
      const size_t ref_oneandzero = ref_oneandzero_unpad(in, len);
      FUZZER_ASSERT_EQUAL(ct_oneandzero, ref_oneandzero);
   }

   if(esp.valid_blocksize(len)) {
      const size_t ct_esp = esp.unpad(in, len);
      const size_t ref_esp = ref_esp_unpad(in, len);
      FUZZER_ASSERT_EQUAL(ct_esp, ref_esp);
   }

   const uint16_t ct_cbc = Botan::TLS::check_tls_cbc_padding(in, len);
   const uint16_t ref_cbc = ref_tls_cbc_unpad(in, len);
   FUZZER_ASSERT_EQUAL(ct_cbc, ref_cbc);
}

1	/*
2	* (C) 2018 Jack Lloyd
3	*
4	* Botan is released under the Simplified BSD License (see license.txt)
5	*/
6
7	#include "fuzzers.h"
8
9	#include <botan/internal/mode_pad.h>
10	#include <botan/internal/tls_cbc.h>
11
12	namespace {
13
14	size_t ref_pkcs7_unpad(const uint8_t in[], size_t len) {	253✔
15	if(len <= 2) {	253✔
16	return len;
17	}
18
19	const size_t padding_length = in[len - 1];	253✔
20
21	if(padding_length == 0 \|\| padding_length > len) {	253✔
22	return len;
23	}
24
25	const size_t padding_start = len - padding_length;	136✔
26
27	for(size_t i = padding_start; i != len; ++i) {	136✔
28	if(in[i] != padding_length) {	136✔
29	return len;
30	}
31	}
32
33	return len - padding_length;
34	}
35
36	size_t ref_x923_unpad(const uint8_t in[], size_t len) {	253✔
37	if(len <= 2) {	253✔
38	return len;
39	}
40
41	const size_t padding_length = in[len - 1];	253✔
42
43	if(padding_length == 0 \|\| padding_length > len) {	253✔
44	return len;
45	}
46	const size_t padding_start = len - padding_length;	136✔
47
48	for(size_t i = padding_start; i != len - 1; ++i) {	136✔
49	if(in[i] != 0) {	136✔
50	return len;
51	}
52	}
53
54	return len - padding_length;
55	}
56
57	size_t ref_oneandzero_unpad(const uint8_t in[], size_t len) {	997✔
58	if(len <= 2) {	997✔
59	return len;
60	}
61
62	size_t idx = len - 1;	997✔
63
64	for(;;) {	997✔
65	if(in[idx] == 0) {	997✔
66	if(idx == 0) {	×
67	return len;
68	}
69	idx -= 1;	×
70	continue;	×
71	} else if(in[idx] == 0x80) {	997✔
72	return idx;
73	} else {
74	return len;	993✔
75	}
76	}
77
78	return len;
79	}
80
81	size_t ref_esp_unpad(const uint8_t in[], size_t len) {	253✔
82	if(len <= 2) {	253✔
83	return len;
84	}
85
86	const size_t padding_bytes = in[len - 1];	253✔
87
88	if(padding_bytes == 0 \|\| padding_bytes > len) {	253✔
89	return len;
90	}
91
92	const size_t padding_start = len - padding_bytes;	136✔
93	for(size_t i = padding_start; i != len; ++i) {	136✔
94	if(in[i] != (i - padding_start + 1)) {	136✔
95	return len;
96	}
97	}
98
99	return len - padding_bytes;
100	}
101
102	uint16_t ref_tls_cbc_unpad(const uint8_t in[], size_t len) {	1,000✔
103	if(len == 0) {	1,000✔
104	return 0;
105	}
106
107	const size_t padding_length = in[(len - 1)];	999✔
108
109	if(padding_length >= len) {	999✔
110	return 0;
111	}
112
113	/*
114	* TLS v1.0 and up require all the padding bytes be the same value
115	* and allows up to 255 bytes.
116	*/
117	for(size_t i = 0; i != 1 + padding_length; ++i) {	1,763✔
118	if(in[(len - i - 1)] != padding_length) {	1,763✔
119	return 0;
120	}
121	}
122	return padding_length + 1;	×
123	}
124
125	} // namespace
126
127	void fuzz(const uint8_t in[], size_t len) {	1,000✔
128	static Botan::PKCS7_Padding pkcs7;	1,000✔
129	static Botan::ANSI_X923_Padding x923;	1,000✔
130	static Botan::OneAndZeros_Padding oneandzero;	1,000✔
131	static Botan::ESP_Padding esp;	1,000✔
132
133	if(pkcs7.valid_blocksize(len)) {	1,000✔
134	const size_t ct_pkcs7 = pkcs7.unpad(in, len);	253✔
135	const size_t ref_pkcs7 = ref_pkcs7_unpad(in, len);	253✔
136	FUZZER_ASSERT_EQUAL(ct_pkcs7, ref_pkcs7);	253✔
137	}
138
139	if(x923.valid_blocksize(len)) {	1,000✔
140	const size_t ct_x923 = x923.unpad(in, len);	253✔
141	const size_t ref_x923 = ref_x923_unpad(in, len);	253✔
142	FUZZER_ASSERT_EQUAL(ct_x923, ref_x923);	253✔
143	}
144
145	if(oneandzero.valid_blocksize(len)) {	1,000✔
146	const size_t ct_oneandzero = oneandzero.unpad(in, len);	997✔
147	const size_t ref_oneandzero = ref_oneandzero_unpad(in, len);	997✔
148	FUZZER_ASSERT_EQUAL(ct_oneandzero, ref_oneandzero);	997✔
149	}
150
151	if(esp.valid_blocksize(len)) {	1,000✔
152	const size_t ct_esp = esp.unpad(in, len);	253✔
153	const size_t ref_esp = ref_esp_unpad(in, len);	253✔
154	FUZZER_ASSERT_EQUAL(ct_esp, ref_esp);	253✔
155	}
156
157	const uint16_t ct_cbc = Botan::TLS::check_tls_cbc_padding(in, len);	1,000✔
158	const uint16_t ref_cbc = ref_tls_cbc_unpad(in, len);	1,000✔
159	FUZZER_ASSERT_EQUAL(ct_cbc, ref_cbc);	1,000✔
160	}	1,000✔

randombit / botan / 5454043422

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous