5111374265

Committed 29 May 2023 11:19AM UTC coverage: 92.227% (+0.5%) from 91.723%

Build # 5111374265

Build Type

push

github

Committed by

randombit

Commit Message

Next release will be 3.1.0. Update release notes

Run Details

75588 of 81959 relevant lines covered (92.23%)

11886470.91 hits per line

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

75.36

/src/lib/compat/sodium/sodium_utils.cpp

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

#include <botan/sodium.h>

#include <botan/mem_ops.h>
#include <botan/system_rng.h>
#include <botan/internal/chacha.h>
#include <botan/internal/ct_utils.h>
#include <botan/internal/loadstor.h>
#include <botan/internal/os_utils.h>
#include <cstdlib>

namespace Botan {

void Sodium::randombytes_buf(void* buf, size_t len) { system_rng().randomize(static_cast<uint8_t*>(buf), len); }

uint32_t Sodium::randombytes_uniform(uint32_t upper_bound) {
   if(upper_bound <= 1)
      return 0;

   // Not completely uniform
   uint64_t x;
   randombytes_buf(&x, sizeof(x));
   return x % upper_bound;
}

void Sodium::randombytes_buf_deterministic(void* buf, size_t size, const uint8_t seed[randombytes_SEEDBYTES]) {
   const unsigned char nonce[12] = {'L', 'i', 'b', 's', 'o', 'd', 'i', 'u', 'm', 'D', 'R', 'G'};

   ChaCha chacha(20);
   chacha.set_key(seed, randombytes_SEEDBYTES);
   chacha.set_iv(nonce, sizeof(nonce));
   chacha.write_keystream(static_cast<uint8_t*>(buf), size);
}

int Sodium::crypto_verify_16(const uint8_t x[16], const uint8_t y[16]) { return same_mem(x, y, 16); }

int Sodium::crypto_verify_32(const uint8_t x[32], const uint8_t y[32]) { return same_mem(x, y, 32); }

int Sodium::crypto_verify_64(const uint8_t x[64], const uint8_t y[64]) { return same_mem(x, y, 64); }

void Sodium::sodium_memzero(void* ptr, size_t len) { secure_scrub_memory(ptr, len); }

int Sodium::sodium_memcmp(const void* x, const void* y, size_t len) {
   const bool same = constant_time_compare(static_cast<const uint8_t*>(x), static_cast<const uint8_t*>(y), len);
   return same ? 0 : -1;
}

int Sodium::sodium_compare(const uint8_t x[], const uint8_t y[], size_t len) {
   const uint8_t LT = static_cast<uint8_t>(-1);
   const uint8_t EQ = 0;
   const uint8_t GT = 1;

   uint8_t result = EQ;  // until found otherwise

   for(size_t i = 0; i != len; ++i) {
      const auto is_eq = CT::Mask<uint8_t>::is_equal(x[i], y[i]);
      const auto is_lt = CT::Mask<uint8_t>::is_lt(x[i], y[i]);
      result = is_eq.select(result, is_lt.select(LT, GT));
   }

   return static_cast<int8_t>(result);
}

int Sodium::sodium_is_zero(const uint8_t b[], size_t len) {
   uint8_t sum = 0;
   for(size_t i = 0; i != len; ++i)
      sum |= b[i];
   return static_cast<int>(CT::Mask<uint8_t>::expand(sum).if_not_set_return(1));
}

void Sodium::sodium_increment(uint8_t b[], size_t len) {
   uint8_t carry = 1;
   for(size_t i = 0; i != len; ++i) {
      b[i] += carry;
      carry &= (b[i] == 0);
   }
}

void Sodium::sodium_add(uint8_t a[], const uint8_t b[], size_t len) {
   uint8_t carry = 0;
   for(size_t i = 0; i != len; ++i) {
      a[i] += b[i] + carry;
      carry = (a[i] < b[i]);
   }
}

void* Sodium::sodium_malloc(size_t size) {
   const uint64_t len = size;

   if(size + sizeof(len) < size)
      return nullptr;

   // NOLINTNEXTLINE(*-no-malloc)
   uint8_t* p = static_cast<uint8_t*>(std::calloc(size + sizeof(len), 1));
   store_le(len, p);
   return p + 8;
}

void Sodium::sodium_free(void* ptr) {
   if(ptr == nullptr)
      return;

   uint8_t* p = static_cast<uint8_t*>(ptr) - 8;
   const uint64_t len = load_le<uint64_t>(p, 0);
   secure_scrub_memory(ptr, static_cast<size_t>(len));
   // NOLINTNEXTLINE(*-no-malloc)
   std::free(p);
}

void* Sodium::sodium_allocarray(size_t count, size_t size) {
   const size_t bytes = count * size;
   if(bytes < count || bytes < size)
      return nullptr;
   return sodium_malloc(bytes);
}

int Sodium::sodium_mprotect_noaccess(void* ptr) {
   OS::page_prohibit_access(ptr);
   return 0;
}

int Sodium::sodium_mprotect_readwrite(void* ptr) {
   OS::page_allow_access(ptr);
   return 0;
}

}  // namespace Botan

1	/*
2	* (C) 2019 Jack Lloyd
3	*
4	* Botan is released under the Simplified BSD License (see license.txt)
5	*/
6
7	#include <botan/sodium.h>
8
9	#include <botan/mem_ops.h>
10	#include <botan/system_rng.h>
11	#include <botan/internal/chacha.h>
12	#include <botan/internal/ct_utils.h>
13	#include <botan/internal/loadstor.h>
14	#include <botan/internal/os_utils.h>
15	#include <cstdlib>
16
17	namespace Botan {
18
19	void Sodium::randombytes_buf(void* buf, size_t len) { system_rng().randomize(static_cast<uint8_t*>(buf), len); }	×
20
21	uint32_t Sodium::randombytes_uniform(uint32_t upper_bound) {	×
22	if(upper_bound <= 1)	×
23	return 0;
24
25	// Not completely uniform
26	uint64_t x;	×
27	randombytes_buf(&x, sizeof(x));	×
28	return x % upper_bound;	×
29	}
30
31	void Sodium::randombytes_buf_deterministic(void* buf, size_t size, const uint8_t seed[randombytes_SEEDBYTES]) {	1✔
32	const unsigned char nonce[12] = {'L', 'i', 'b', 's', 'o', 'd', 'i', 'u', 'm', 'D', 'R', 'G'};	1✔
33
34	ChaCha chacha(20);	1✔
35	chacha.set_key(seed, randombytes_SEEDBYTES);	1✔
36	chacha.set_iv(nonce, sizeof(nonce));	1✔
37	chacha.write_keystream(static_cast<uint8_t*>(buf), size);	1✔
38	}	1✔
39
40	int Sodium::crypto_verify_16(const uint8_t x[16], const uint8_t y[16]) { return same_mem(x, y, 16); }	2✔
41
42	int Sodium::crypto_verify_32(const uint8_t x[32], const uint8_t y[32]) { return same_mem(x, y, 32); }	4✔
43
44	int Sodium::crypto_verify_64(const uint8_t x[64], const uint8_t y[64]) { return same_mem(x, y, 64); }	2✔
45
46	void Sodium::sodium_memzero(void* ptr, size_t len) { secure_scrub_memory(ptr, len); }	×
47
48	int Sodium::sodium_memcmp(const void* x, const void* y, size_t len) {	3✔
49	const bool same = constant_time_compare(static_cast<const uint8_t>(x), static_cast<const uint8_t>(y), len);	3✔
50	return same ? 0 : -1;	3✔
51	}
52
53	int Sodium::sodium_compare(const uint8_t x[], const uint8_t y[], size_t len) {	3✔
54	const uint8_t LT = static_cast<uint8_t>(-1);	3✔
55	const uint8_t EQ = 0;	3✔
56	const uint8_t GT = 1;	3✔
57
58	uint8_t result = EQ; // until found otherwise	3✔
59
60	for(size_t i = 0; i != len; ++i) {	18✔
61	const auto is_eq = CT::Mask<uint8_t>::is_equal(x[i], y[i]);	15✔
62	const auto is_lt = CT::Mask<uint8_t>::is_lt(x[i], y[i]);	15✔
63	result = is_eq.select(result, is_lt.select(LT, GT));	15✔
64	}
65
66	return static_cast<int8_t>(result);	3✔
67	}
68
69	int Sodium::sodium_is_zero(const uint8_t b[], size_t len) {	3✔
70	uint8_t sum = 0;	3✔
71	for(size_t i = 0; i != len; ++i)	13✔
72	sum \|= b[i];	10✔
73	return static_cast<int>(CT::Mask<uint8_t>::expand(sum).if_not_set_return(1));	3✔
74	}
75
76	void Sodium::sodium_increment(uint8_t b[], size_t len) {	3✔
77	uint8_t carry = 1;	3✔
78	for(size_t i = 0; i != len; ++i) {	18✔
79	b[i] += carry;	15✔
80	carry &= (b[i] == 0);	15✔
81	}
82	}	3✔
83
84	void Sodium::sodium_add(uint8_t a[], const uint8_t b[], size_t len) {	4✔
85	uint8_t carry = 0;	4✔
86	for(size_t i = 0; i != len; ++i) {	24✔
87	a[i] += b[i] + carry;	20✔
88	carry = (a[i] < b[i]);	20✔
89	}
90	}	4✔
91
92	void* Sodium::sodium_malloc(size_t size) {	1✔
93	const uint64_t len = size;	1✔
94
95	if(size + sizeof(len) < size)	1✔
96	return nullptr;
97
98	// NOLINTNEXTLINE(*-no-malloc)
99	uint8_t* p = static_cast<uint8_t*>(std::calloc(size + sizeof(len), 1));	1✔
100	store_le(len, p);	1✔
101	return p + 8;	1✔
102	}
103
104	void Sodium::sodium_free(void* ptr) {	2✔
105	if(ptr == nullptr)	2✔
106	return;
107
108	uint8_t* p = static_cast<uint8_t*>(ptr) - 8;	1✔
109	const uint64_t len = load_le<uint64_t>(p, 0);	1✔
110	secure_scrub_memory(ptr, static_cast<size_t>(len));	1✔
111	// NOLINTNEXTLINE(*-no-malloc)
112	std::free(p);	1✔
113	}
114
115	void* Sodium::sodium_allocarray(size_t count, size_t size) {	×
116	const size_t bytes = count * size;	×
117	if(bytes < count \|\| bytes < size)	×
118	return nullptr;
119	return sodium_malloc(bytes);	×
120	}
121
122	int Sodium::sodium_mprotect_noaccess(void* ptr) {	×
123	OS::page_prohibit_access(ptr);	×
124	return 0;	×
125	}
126
127	int Sodium::sodium_mprotect_readwrite(void* ptr) {	×
128	OS::page_allow_access(ptr);	×
129	return 0;	×
130	}
131
132	} // namespace Botan

randombit / botan / 5111374265

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