5356685938

Committed 23 Jun 2023 01:39PM UTC coverage: 91.746% (+0.02%) from 91.728%

Build # 5356685938

Build Type

push

github

Committed by

randombit

Commit Message

Merge GH #3595 Apply clang-tidy more universally

Previously clang-tidy ruleset disabled certain rules for the cli and
tests. Remove these exceptions, and fix the relevant warnings.

Also fix compile_commands.json which had previously not provided information for
the examples, BoGo shim, or fuzzers. As a result, clang-tidy was effectively
blind to them. Fix various clang-tidy findings in these files.

Additionally fix clang-tidy warnings that were in Boost or Sqlite3 specific
code, which had been accidentally omitted in past checks.

Modify the nightly clang-tidy run to additionally check the examples, fuzzers,
shim, and Sqlite3/Boost specific code.

Run Details

78183 of 85217 relevant lines covered (91.75%)

12364366.11 hits per line

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

66.67

/src/fuzzer/oaep.cpp

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

#include "fuzzers.h"

#include <botan/hex.h>
#include <botan/internal/oaep.h>

namespace {

Botan::secure_vector<uint8_t> ref_oaep_unpad(uint8_t& valid_mask,
                                             const uint8_t in[],
                                             size_t len,
                                             const Botan::secure_vector<uint8_t>& Phash) {
   const size_t hlen = Phash.size();

   if(len < 2 * hlen + 1) {
      return Botan::secure_vector<uint8_t>();
   }

   for(size_t i = hlen; i != 2 * hlen; ++i) {
      if(in[i] != Phash[i - hlen]) {
         return Botan::secure_vector<uint8_t>();
      }
   }

   for(size_t i = 2 * hlen; i != len; ++i) {
      if(in[i] != 0x00 && in[i] != 0x01) {
         return Botan::secure_vector<uint8_t>();
      }

      if(in[i] == 0x01) {
         valid_mask = 0xFF;
         return Botan::secure_vector<uint8_t>(in + i + 1, in + len);
      }
   }

   return Botan::secure_vector<uint8_t>();
}

inline bool all_zeros(const Botan::secure_vector<uint8_t>& v) {
   for(size_t i = 0; i != v.size(); ++i) {
      if(v[i] != 0) {
         return false;
      }
   }
   return true;
}

}  // namespace

void fuzz(const uint8_t in[], size_t len) {
   static const Botan::secure_vector<uint8_t> Phash = {1, 2, 3, 4};

   uint8_t lib_valid_mask = 0;
   const Botan::secure_vector<uint8_t> lib_output = Botan::oaep_find_delim(lib_valid_mask, in, len, Phash);
   FUZZER_ASSERT_TRUE(lib_valid_mask == 0 || lib_valid_mask == 0xFF);

   uint8_t ref_valid_mask = 0;
   const Botan::secure_vector<uint8_t> ref_output = ref_oaep_unpad(ref_valid_mask, in, len, Phash);
   FUZZER_ASSERT_TRUE(ref_valid_mask == 0 || ref_valid_mask == 0xFF);

   if(ref_valid_mask == 0xFF && lib_valid_mask == 0x00) {
      FUZZER_WRITE_AND_CRASH("Ref accepted but library rejected, output " << Botan::hex_encode(ref_output) << "\n");
   } else if(ref_valid_mask == 0x00 && lib_valid_mask == 0xFF) {
      FUZZER_WRITE_AND_CRASH("Lib accepted but ref rejected, output = " << Botan::hex_encode(lib_output) << "\n");
   }

   if(ref_valid_mask == 0x00) {
      FUZZER_ASSERT_TRUE(all_zeros(ref_output));
   }

   if(lib_valid_mask == 0x00) {
      FUZZER_ASSERT_TRUE(all_zeros(lib_output));
   }

   if(ref_valid_mask && lib_valid_mask) {
      if(ref_output != lib_output) {
         FUZZER_WRITE_AND_CRASH("Ref and lib both accepted but produced different output:"
                                << " ref = " << Botan::hex_encode(ref_output)
                                << " lib = " << Botan::hex_encode(lib_output));
      }
   }
}

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/hex.h>
10	#include <botan/internal/oaep.h>
11
12	namespace {
13
14	Botan::secure_vector<uint8_t> ref_oaep_unpad(uint8_t& valid_mask,	1,000✔
15	const uint8_t in[],
16	size_t len,
17	const Botan::secure_vector<uint8_t>& Phash) {
18	const size_t hlen = Phash.size();	1,000✔
19
20	if(len < 2 * hlen + 1) {	1,000✔
21	return Botan::secure_vector<uint8_t>();	9✔
22	}
23
24	for(size_t i = hlen; i != 2 * hlen; ++i) {	994✔
25	if(in[i] != Phash[i - hlen]) {	994✔
26	return Botan::secure_vector<uint8_t>();	991✔
27	}
28	}
29
30	for(size_t i = 2 * hlen; i != len; ++i) {	×
31	if(in[i] != 0x00 && in[i] != 0x01) {	×
32	return Botan::secure_vector<uint8_t>();	×
33	}
34
35	if(in[i] == 0x01) {	×
36	valid_mask = 0xFF;	×
37	return Botan::secure_vector<uint8_t>(in + i + 1, in + len);	×
38	}
39	}
40
41	return Botan::secure_vector<uint8_t>();	×
42	}
43
44	inline bool all_zeros(const Botan::secure_vector<uint8_t>& v) {
45	for(size_t i = 0; i != v.size(); ++i) {	2,000✔
46	if(v[i] != 0) {	×
47	return false;
48	}
49	}
50	return true;
51	}
52
53	} // namespace
54
55	void fuzz(const uint8_t in[], size_t len) {	1,000✔
56	static const Botan::secure_vector<uint8_t> Phash = {1, 2, 3, 4};	1,000✔
57
58	uint8_t lib_valid_mask = 0;	1,000✔
59	const Botan::secure_vector<uint8_t> lib_output = Botan::oaep_find_delim(lib_valid_mask, in, len, Phash);	1,000✔
60	FUZZER_ASSERT_TRUE(lib_valid_mask == 0 \|\| lib_valid_mask == 0xFF);	1,000✔
61
62	uint8_t ref_valid_mask = 0;	1,000✔
63	const Botan::secure_vector<uint8_t> ref_output = ref_oaep_unpad(ref_valid_mask, in, len, Phash);	1,000✔
64	FUZZER_ASSERT_TRUE(ref_valid_mask == 0 \|\| ref_valid_mask == 0xFF);	1,000✔
65
66	if(ref_valid_mask == 0xFF && lib_valid_mask == 0x00) {	1,000✔
67	FUZZER_WRITE_AND_CRASH("Ref accepted but library rejected, output " << Botan::hex_encode(ref_output) << "\n");	×
68	} else if(ref_valid_mask == 0x00 && lib_valid_mask == 0xFF) {	1,000✔
69	FUZZER_WRITE_AND_CRASH("Lib accepted but ref rejected, output = " << Botan::hex_encode(lib_output) << "\n");	×
70	}
71
72	if(ref_valid_mask == 0x00) {	1,000✔
73	FUZZER_ASSERT_TRUE(all_zeros(ref_output));	1,000✔
74	}
75
76	if(lib_valid_mask == 0x00) {	1,000✔
77	FUZZER_ASSERT_TRUE(all_zeros(lib_output));	1,000✔
78	}
79
80	if(ref_valid_mask && lib_valid_mask) {	1,000✔
81	if(ref_output != lib_output) {	×
82	FUZZER_WRITE_AND_CRASH("Ref and lib both accepted but produced different output:"	×
83	<< " ref = " << Botan::hex_encode(ref_output)
84	<< " lib = " << Botan::hex_encode(lib_output));
85	}
86	}
87	}	1,991✔

randombit / botan / 5356685938

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