Botan 3.14.1
Crypto and TLS for C&
sodium_utils.cpp
Go to the documentation of this file.
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 <algorithm>
15#include <cstddef>
16#include <cstdlib>
17
18namespace Botan {
19
20void Sodium::randombytes_buf(void* buf, size_t len) {
21 system_rng().randomize(static_cast<uint8_t*>(buf), len);
22}
23
24uint32_t Sodium::randombytes_uniform(uint32_t upper_bound) {
25 if(upper_bound <= 1) {
26 return 0;
27 }
28
29 // Reject values below 2^32 mod upper_bound to avoid modulo bias
30 const uint32_t min = (~upper_bound + 1) % upper_bound;
31
32 uint32_t x = 0;
33 do { // NOLINT(*-avoid-do-while)
34 randombytes_buf(&x, sizeof(x));
35 } while(x < min);
36
37 return x % upper_bound;
38}
39
40void Sodium::randombytes_buf_deterministic(void* buf, size_t size, const uint8_t seed[randombytes_SEEDBYTES]) {
41 const unsigned char nonce[12] = {'L', 'i', 'b', 's', 'o', 'd', 'i', 'u', 'm', 'D', 'R', 'G'};
42
43 ChaCha chacha(20);
44 chacha.set_key(seed, randombytes_SEEDBYTES);
45 chacha.set_iv(nonce, sizeof(nonce));
46 chacha.write_keystream(static_cast<uint8_t*>(buf), size);
47}
48
49int Sodium::crypto_verify_16(const uint8_t x[16], const uint8_t y[16]) {
50 return static_cast<int>(CT::is_equal(x, y, 16).select(1, 0)) - 1;
51}
52
53int Sodium::crypto_verify_32(const uint8_t x[32], const uint8_t y[32]) {
54 return static_cast<int>(CT::is_equal(x, y, 32).select(1, 0)) - 1;
55}
56
57int Sodium::crypto_verify_64(const uint8_t x[64], const uint8_t y[64]) {
58 return static_cast<int>(CT::is_equal(x, y, 64).select(1, 0)) - 1;
59}
60
61void Sodium::sodium_memzero(void* ptr, size_t len) {
62 secure_scrub_memory(ptr, len);
63}
64
65int Sodium::sodium_memcmp(const void* x, const void* y, size_t len) {
66 const auto same = CT::is_equal(static_cast<const uint8_t*>(x), static_cast<const uint8_t*>(y), len);
67 // Return 0 if same or -1 if differing
68 return static_cast<int>(same.select(1, 0)) - 1;
69}
70
71int Sodium::sodium_compare(const uint8_t x[], const uint8_t y[], size_t len) {
72 const uint8_t LT = static_cast<uint8_t>(-1);
73 const uint8_t EQ = 0;
74 const uint8_t GT = 1;
75
76 uint8_t result = EQ; // until found otherwise
77
78 for(size_t i = 0; i != len; ++i) {
79 const auto is_eq = CT::Mask<uint8_t>::is_equal(x[i], y[i]);
80 const auto is_lt = CT::Mask<uint8_t>::is_lt(x[i], y[i]);
81 result = is_eq.select(result, is_lt.select(LT, GT));
82 }
83
84 return static_cast<int8_t>(result);
85}
86
87int Sodium::sodium_is_zero(const uint8_t b[], size_t len) {
88 uint8_t sum = 0;
89 for(size_t i = 0; i != len; ++i) {
90 sum |= b[i];
91 }
92 return static_cast<int>(CT::Mask<uint8_t>::expand(sum).if_not_set_return(1));
93}
94
95void Sodium::sodium_increment(uint8_t b[], size_t len) {
96 uint8_t carry = 1;
97 for(size_t i = 0; i != len; ++i) {
98 b[i] += carry;
99 carry &= CT::Mask<uint8_t>::is_zero(b[i]).if_set_return(1);
100 }
101}
102
103void Sodium::sodium_add(uint8_t a[], const uint8_t b[], size_t len) {
104 uint16_t carry = 0;
105 for(size_t i = 0; i != len; ++i) {
106 carry += static_cast<uint16_t>(a[i]) + b[i];
107 a[i] = static_cast<uint8_t>(carry);
108 carry >>= 8;
109 }
110}
111
112namespace {
113
114// The length prefix is padded so the returned pointer keeps calloc's alignment
115constexpr size_t sodium_malloc_prefix = std::max(sizeof(uint64_t), alignof(std::max_align_t));
116
117} // namespace
118
119void* Sodium::sodium_malloc(size_t size) {
120 const uint64_t len = size;
121
122 if(size + sodium_malloc_prefix < size) {
123 return nullptr;
124 }
125
126 // NOLINTNEXTLINE(*-no-malloc,*-owning-memory,*-const-correctness)
127 uint8_t* p = static_cast<uint8_t*>(std::calloc(size + sodium_malloc_prefix, 1));
128 if(p == nullptr) {
129 return nullptr;
130 }
131 store_le(len, p);
132 return p + sodium_malloc_prefix;
133}
134
135void Sodium::sodium_free(void* ptr) {
136 if(ptr == nullptr) {
137 return;
138 }
139
140 uint8_t* p = static_cast<uint8_t*>(ptr) - sodium_malloc_prefix;
141 const uint64_t len = load_le<uint64_t>(p, 0);
142 secure_scrub_memory(ptr, static_cast<size_t>(len));
143 // NOLINTNEXTLINE(*-no-malloc,*-owning-memory)
144 std::free(p);
145}
146
147void* Sodium::sodium_allocarray(size_t count, size_t size) {
148 if(count > 0 && size > SIZE_MAX / count) {
149 return nullptr;
150 }
151 return sodium_malloc(count * size);
152}
153
155 BOTAN_UNUSED(ptr);
156 return -1;
157}
158
160 BOTAN_UNUSED(ptr);
161 return -1;
162}
163
164} // namespace Botan
#define BOTAN_UNUSED
Definition assert.h:151
static constexpr Mask< T > expand(T v)
Definition ct_utils.h:397
static constexpr Mask< T > is_equal(T x, T y)
Definition ct_utils.h:447
static constexpr Mask< T > is_lt(T x, T y)
Definition ct_utils.h:455
static constexpr Mask< T > is_zero(T x)
Definition ct_utils.h:442
void randomize(std::span< uint8_t > output)
Definition rng.h:86
void set_iv(const uint8_t iv[], size_t iv_len)
void write_keystream(uint8_t out[], size_t len)
void set_key(const OctetString &key)
Definition sym_algo.cpp:14
constexpr CT::Mask< T > is_equal(const T x[], const T y[], size_t len)
Definition ct_utils.h:803
@ randombytes_SEEDBYTES
Definition sodium.h:149
int crypto_verify_32(const uint8_t x[32], const uint8_t y[32])
int crypto_verify_16(const uint8_t x[16], const uint8_t y[16])
void * sodium_allocarray(size_t count, size_t size)
int sodium_memcmp(const void *x, const void *y, size_t len)
int crypto_verify_64(const uint8_t x[64], const uint8_t y[64])
void sodium_add(uint8_t a[], const uint8_t b[], size_t len)
void * sodium_malloc(size_t size)
void sodium_increment(uint8_t n[], size_t nlen)
int sodium_compare(const uint8_t x[], const uint8_t y[], size_t len)
int sodium_mprotect_noaccess(void *ptr)
void randombytes_buf_deterministic(void *buf, size_t size, const uint8_t seed[randombytes_SEEDBYTES])
int sodium_is_zero(const uint8_t nonce[], size_t nlen)
void sodium_free(void *ptr)
uint32_t randombytes_uniform(uint32_t upper_bound)
int sodium_mprotect_readwrite(void *ptr)
void sodium_memzero(void *ptr, size_t len)
void randombytes_buf(void *buf, size_t size)
RandomNumberGenerator & system_rng()
void secure_scrub_memory(void *ptr, size_t n)
Definition mem_utils.cpp:24
constexpr auto store_le(ParamTs &&... params)
Definition loadstor.h:736
constexpr auto load_le(ParamTs &&... params)
Definition loadstor.h:495