5132265391

Committed 31 May 2023 12:12PM UTC coverage: 91.995% (-0.02%) from 92.013%

Build # 5132265391

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #3564 from randombit/pqc/prep_for_sphincsplus

Utility Preparations for SPHINCS+

Run Details

75952 of 82561 relevant lines covered (92.0%)

11862114.99 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	const size_t padding_length = in[len - 1];	253✔
19
20	if(padding_length == 0 \|\| padding_length > len)	253✔
21	return len;
22
23	const size_t padding_start = len - padding_length;	127✔
24
25	for(size_t i = padding_start; i != len; ++i) {	129✔
26	if(in[i] != padding_length)	128✔
27	return len;
28	}
29
30	return len - padding_length;
31	}
32
33	size_t ref_x923_unpad(const uint8_t in[], size_t len) {	253✔
34	if(len <= 2)	253✔
35	return len;
36
37	const size_t padding_length = in[len - 1];	253✔
38
39	if(padding_length == 0 \|\| padding_length > len)	253✔
40	return len;
41	const size_t padding_start = len - padding_length;	127✔
42
43	for(size_t i = padding_start; i != len - 1; ++i) {	128✔
44	if(in[i] != 0) {	127✔
45	return len;
46	}
47	}
48
49	return len - padding_length;
50	}
51
52	size_t ref_oneandzero_unpad(const uint8_t in[], size_t len) {	997✔
53	if(len <= 2)	997✔
54	return len;
55
56	size_t idx = len - 1;	997✔
57
58	for(;;) {	997✔
59	if(in[idx] == 0) {	997✔
60	if(idx == 0)	×
61	return len;
62	idx -= 1;	×
63	continue;	×
64	} else if(in[idx] == 0x80) {	997✔
65	return idx;
66	} else
67	return len;	994✔
68	}
69
70	return len;
71	}
72
73	size_t ref_esp_unpad(const uint8_t in[], size_t len) {	253✔
74	if(len <= 2)	253✔
75	return len;
76
77	const size_t padding_bytes = in[len - 1];	253✔
78
79	if(padding_bytes == 0 \|\| padding_bytes > len) {	253✔
80	return len;
81	}
82
83	const size_t padding_start = len - padding_bytes;	127✔
84	for(size_t i = padding_start; i != len; ++i) {	128✔
85	if(in[i] != (i - padding_start + 1)) {	127✔
86	return len;
87	}
88	}
89
90	return len - padding_bytes;
91	}
92
93	uint16_t ref_tls_cbc_unpad(const uint8_t in[], size_t len) {	1,000✔
94	if(len == 0)	1,000✔
95	return 0;
96
97	const size_t padding_length = in[(len - 1)];	999✔
98
99	if(padding_length >= len)	999✔
100	return 0;
101
102	/*
103	* TLS v1.0 and up require all the padding bytes be the same value
104	* and allows up to 255 bytes.
105	*/
106	for(size_t i = 0; i != 1 + padding_length; ++i) {	1,745✔
107	if(in[(len - i - 1)] != padding_length)	1,745✔
108	return 0;
109	}
110	return padding_length + 1;	×
111	}
112
113	} // namespace
114
115	void fuzz(const uint8_t in[], size_t len) {	1,000✔
116	static Botan::PKCS7_Padding pkcs7;	1,000✔
117	static Botan::ANSI_X923_Padding x923;	1,000✔
118	static Botan::OneAndZeros_Padding oneandzero;	1,000✔
119	static Botan::ESP_Padding esp;	1,000✔
120
121	if(pkcs7.valid_blocksize(len)) {	1,000✔
122	const size_t ct_pkcs7 = pkcs7.unpad(in, len);	253✔
123	const size_t ref_pkcs7 = ref_pkcs7_unpad(in, len);	253✔
124	FUZZER_ASSERT_EQUAL(ct_pkcs7, ref_pkcs7);	253✔
125	}
126
127	if(x923.valid_blocksize(len)) {	1,000✔
128	const size_t ct_x923 = x923.unpad(in, len);	253✔
129	const size_t ref_x923 = ref_x923_unpad(in, len);	253✔
130	FUZZER_ASSERT_EQUAL(ct_x923, ref_x923);	253✔
131	}
132
133	if(oneandzero.valid_blocksize(len)) {	1,000✔
134	const size_t ct_oneandzero = oneandzero.unpad(in, len);	997✔
135	const size_t ref_oneandzero = ref_oneandzero_unpad(in, len);	997✔
136	FUZZER_ASSERT_EQUAL(ct_oneandzero, ref_oneandzero);	997✔
137	}
138
139	if(esp.valid_blocksize(len)) {	1,000✔
140	const size_t ct_esp = esp.unpad(in, len);	253✔
141	const size_t ref_esp = ref_esp_unpad(in, len);	253✔
142	FUZZER_ASSERT_EQUAL(ct_esp, ref_esp);	253✔
143	}
144
145	const uint16_t ct_cbc = Botan::TLS::check_tls_cbc_padding(in, len);	1,000✔
146	const uint16_t ref_cbc = ref_tls_cbc_unpad(in, len);	1,000✔
147	FUZZER_ASSERT_EQUAL(ct_cbc, ref_cbc);	1,000✔
148	}	1,000✔

randombit / botan / 5132265391

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