Botan 2.19.5 Crypto and TLS for C&

poly1305.cpp
Go to the documentation of this file.
1/*
2* Derived from poly1305-donna-64.h by Andrew Moon <liquidsun@gmail.com>
3* in https://github.com/floodyberry/poly1305-donna
4*
5* (C) 2014 Andrew Moon
6* (C) 2014 Jack Lloyd
7*
8* Botan is released under the Simplified BSD License (see license.txt)
9*/
10
11#include <botan/poly1305.h>
12#include <botan/loadstor.h>
13#include <botan/mul128.h>
14#include <botan/internal/donna128.h>
15#include <botan/internal/ct_utils.h>
16
17 namespace Botan {
18
19 namespace {
20
21 void poly1305_init(secure_vector<uint64_t>& X, const uint8_t key[32])
22 {
23 /* r &= 0xffffffc0ffffffc0ffffffc0fffffff */
24 const uint64_t t0 = load_le<uint64_t>(key, 0);
25 const uint64_t t1 = load_le<uint64_t>(key, 1);
26
27 X[0] = ( t0 ) & 0xffc0fffffff;
28 X[1] = ((t0 >> 44) | (t1 << 20)) & 0xfffffc0ffff;
29 X[2] = ((t1 >> 24) ) & 0x00ffffffc0f;
30
31 /* h = 0 */
32 X[3] = 0;
33 X[4] = 0;
34 X[5] = 0;
35
36 /* save pad for later */
37 X[6] = load_le<uint64_t>(key, 2);
38 X[7] = load_le<uint64_t>(key, 3);
39 }
40
41 void poly1305_blocks(secure_vector<uint64_t>& X, const uint8_t *m, size_t blocks, bool is_final = false)
42 {
43#if !defined(BOTAN_TARGET_HAS_NATIVE_UINT128)
44 typedef donna128 uint128_t;
45#endif
46
47 const uint64_t hibit = is_final ? 0 : (static_cast<uint64_t>(1) << 40); /* 1 << 128 */
48
49 const uint64_t r0 = X[0];
50 const uint64_t r1 = X[1];
51 const uint64_t r2 = X[2];
52
53 const uint64_t M44 = 0xFFFFFFFFFFF;
54 const uint64_t M42 = 0x3FFFFFFFFFF;
55
56 uint64_t h0 = X[3+0];
57 uint64_t h1 = X[3+1];
58 uint64_t h2 = X[3+2];
59
60 const uint64_t s1 = r1 * 20;
61 const uint64_t s2 = r2 * 20;
62
63 for(size_t i = 0; i != blocks; ++i)
64 {
65 const uint64_t t0 = load_le<uint64_t>(m, 0);
66 const uint64_t t1 = load_le<uint64_t>(m, 1);
67
68 h0 += (( t0 ) & M44);
69 h1 += (((t0 >> 44) | (t1 << 20)) & M44);
70 h2 += (((t1 >> 24) ) & M42) | hibit;
71
72 const uint128_t d0 = uint128_t(h0) * r0 + uint128_t(h1) * s2 + uint128_t(h2) * s1;
73 const uint64_t c0 = carry_shift(d0, 44);
74
75 const uint128_t d1 = uint128_t(h0) * r1 + uint128_t(h1) * r0 + uint128_t(h2) * s2 + c0;
76 const uint64_t c1 = carry_shift(d1, 44);
77
78 const uint128_t d2 = uint128_t(h0) * r2 + uint128_t(h1) * r1 + uint128_t(h2) * r0 + c1;
79 const uint64_t c2 = carry_shift(d2, 42);
80
81 h0 = d0 & M44;
82 h1 = d1 & M44;
83 h2 = d2 & M42;
84
85 h0 += c2 * 5;
86 h1 += carry_shift(h0, 44);
87 h0 = h0 & M44;
88
89 m += 16;
90 }
91
92 X[3+0] = h0;
93 X[3+1] = h1;
94 X[3+2] = h2;
95 }
96
97 void poly1305_finish(secure_vector<uint64_t>& X, uint8_t mac[16])
98 {
99 const uint64_t M44 = 0xFFFFFFFFFFF;
100 const uint64_t M42 = 0x3FFFFFFFFFF;
101
102 /* fully carry h */
103 uint64_t h0 = X[3+0];
104 uint64_t h1 = X[3+1];
105 uint64_t h2 = X[3+2];
106
107 uint64_t c;
108 c = (h1 >> 44); h1 &= M44;
109 h2 += c; c = (h2 >> 42); h2 &= M42;
110 h0 += c * 5; c = (h0 >> 44); h0 &= M44;
111 h1 += c; c = (h1 >> 44); h1 &= M44;
112 h2 += c; c = (h2 >> 42); h2 &= M42;
113 h0 += c * 5; c = (h0 >> 44); h0 &= M44;
114 h1 += c;
115
116 /* compute h + -p */
117 uint64_t g0 = h0 + 5; c = (g0 >> 44); g0 &= M44;
118 uint64_t g1 = h1 + c; c = (g1 >> 44); g1 &= M44;
119 uint64_t g2 = h2 + c - (static_cast<uint64_t>(1) << 42);
120
121 /* select h if h < p, or h + -p if h >= p */
122 const auto c_mask = CT::Mask<uint64_t>::expand(c);
123 h0 = c_mask.select(g0, h0);
124 h1 = c_mask.select(g1, h1);
125 h2 = c_mask.select(g2, h2);
126
127 /* h = (h + pad) */
128 const uint64_t t0 = X[6];
129 const uint64_t t1 = X[7];
130
131 h0 += (( t0 ) & M44) ; c = (h0 >> 44); h0 &= M44;
132 h1 += (((t0 >> 44) | (t1 << 20)) & M44) + c; c = (h1 >> 44); h1 &= M44;
133 h2 += (((t1 >> 24) ) & M42) + c; h2 &= M42;
134
135 /* mac = h % (2^128) */
136 h0 = ((h0 ) | (h1 << 44));
137 h1 = ((h1 >> 20) | (h2 << 24));
138
139 store_le(mac, h0, h1);
140
141 /* zero out the state */
142 clear_mem(X.data(), X.size());
143 }
144
145}
146
147 void Poly1305::clear()
148 {
149 zap(m_poly);
150 zap(m_buf);
151 m_buf_pos = 0;
152 }
153
154 void Poly1305::key_schedule(const uint8_t key[], size_t)
155 {
156 m_buf_pos = 0;
157 m_buf.resize(16);
158 m_poly.resize(8);
159
160 poly1305_init(m_poly, key);
161 }
162
163 void Poly1305::add_data(const uint8_t input[], size_t length)
164 {
165 verify_key_set(m_poly.size() == 8);
166
167 if(m_buf_pos)
168 {
169 buffer_insert(m_buf, m_buf_pos, input, length);
170
171 if(m_buf_pos + length >= m_buf.size())
172 {
173 poly1305_blocks(m_poly, m_buf.data(), 1);
174 input += (m_buf.size() - m_buf_pos);
175 length -= (m_buf.size() - m_buf_pos);
176 m_buf_pos = 0;
177 }
178 }
179
180 const size_t full_blocks = length / m_buf.size();
181 const size_t remaining = length % m_buf.size();
182
183 if(full_blocks)
184 poly1305_blocks(m_poly, input, full_blocks);
185
186 buffer_insert(m_buf, m_buf_pos, input + full_blocks * m_buf.size(), remaining);
187 m_buf_pos += remaining;
188 }
189
190 void Poly1305::final_result(uint8_t out[])
191 {
192 verify_key_set(m_poly.size() == 8);
193
194 if(m_buf_pos != 0)
195 {
196 m_buf[m_buf_pos] = 1;
197 const size_t len = m_buf.size() - m_buf_pos - 1;
198 if (len > 0)
199 {
200 clear_mem(&m_buf[m_buf_pos+1], len);
201 }
202 poly1305_blocks(m_poly, m_buf.data(), 1, true);
203 }
204
205 poly1305_finish(m_poly, out);
206
207 m_poly.clear();
208 m_buf_pos = 0;
209 }
210
211}
Botan::CT::Mask::expand
static Mask< T > expand(T v)
Definition: ct_utils.h:123
Botan::Poly1305::clear
void clear() override
Definition: poly1305.cpp:147
Botan::SymmetricAlgorithm::verify_key_set
void verify_key_set(bool cond) const
Definition: sym_algo.h:171
X
fe X
Definition: ge.cpp:27
Botan
Definition: alg_id.cpp:13
Botan::buffer_insert
size_t buffer_insert(std::vector< T, Alloc > &buf, size_t buf_offset, const T input[], size_t input_length)
Definition: mem_ops.h:228
Botan::zap
void zap(std::vector< T, Alloc > &vec)
Definition: secmem.h:124
Botan::carry_shift
uint64_t carry_shift(const donna128 &a, size_t shift)
Definition: donna128.h:116
Botan::store_le
void store_le(uint16_t in, uint8_t out[2])
Definition: loadstor.h:454
Botan::clear_mem
void clear_mem(T *ptr, size_t n)
Definition: mem_ops.h:115
Botan::load_le< uint64_t >
uint64_t load_le< uint64_t >(const uint8_t in[], size_t off)
Definition: loadstor.h:237