Line data Source code
1 : /* fd_aes_ref.c was imported from the OpenSSL project circa 2023-Aug.
2 : Original source files: crypto/evp/e_aes.c crypto/modes/gcm128.c */
3 :
4 : #include "fd_aes_gcm.h"
5 :
6 : #include <assert.h>
7 :
8 4258585 : #define fd_gcm_init fd_gcm_init_4bit
9 4001692 : #define fd_gcm_gmult fd_gcm_gmult_4bit
10 12705571 : #define fd_gcm_ghash fd_gcm_ghash_4bit
11 :
12 : static void
13 : fd_aes_gcm_setiv( fd_aes_gcm_ref_t * gcm,
14 4258585 : uchar const iv[ 12 ] ) {
15 :
16 4258585 : uint ctr;
17 4258585 : gcm->len.u[ 0 ] = 0; /* AAD length */
18 4258585 : gcm->len.u[ 1 ] = 0; /* Message length */
19 4258585 : gcm->ares = 0;
20 4258585 : gcm->mres = 0;
21 :
22 4258585 : memcpy( gcm->Yi.c, iv, 12 );
23 4258585 : gcm->Yi.c[12] = 0;
24 4258585 : gcm->Yi.c[13] = 0;
25 4258585 : gcm->Yi.c[14] = 0;
26 4258585 : gcm->Yi.c[15] = 1;
27 4258585 : ctr = 1;
28 :
29 4258585 : gcm->Xi.u[0] = 0;
30 4258585 : gcm->Xi.u[1] = 0;
31 :
32 4258585 : fd_aes_encrypt( gcm->Yi.c, gcm->EK0.c, &gcm->key );
33 4258585 : ctr++;
34 :
35 4258585 : gcm->Yi.d[3] = fd_uint_bswap( ctr );
36 4258585 : }
37 :
38 : void
39 : fd_aes_128_gcm_init_ref( fd_aes_gcm_ref_t * gcm,
40 : uchar const key[ 16 ],
41 4258585 : uchar const iv[ 12 ] ) {
42 :
43 : /* TODO: Check key size */
44 :
45 4258585 : memset( gcm, 0, sizeof(fd_aes_gcm_t) );
46 :
47 4258585 : fd_aes_key_ref_t * ks = &gcm->key;
48 4258585 : fd_aes_set_encrypt_key( key, 128, ks );
49 :
50 4258585 : fd_aes_encrypt( gcm->H.c, gcm->H.c, ks );
51 4258585 : gcm->H.u[ 0 ] = fd_ulong_bswap( gcm->H.u[ 0 ] );
52 4258585 : gcm->H.u[ 1 ] = fd_ulong_bswap( gcm->H.u[ 1 ] );
53 :
54 4258585 : fd_gcm_init( gcm->Htable, gcm->H.u );
55 4258585 : fd_aes_gcm_setiv( gcm, iv );
56 4258585 : }
57 :
58 : static int
59 : fd_gcm128_aad( fd_aes_gcm_ref_t * aes_gcm,
60 : uchar const * aad,
61 4258585 : ulong aad_sz ) {
62 :
63 4258585 : ulong alen = aes_gcm->len.u[ 0 ];
64 :
65 4258585 : if( FD_UNLIKELY( aes_gcm->len.u[ 1 ] ) )
66 0 : return -2;
67 :
68 4258585 : alen += aad_sz;
69 4258585 : if (alen > (1UL<<61) || (sizeof(aad_sz) == 8 && alen < aad_sz))
70 0 : return -1;
71 4258585 : aes_gcm->len.u[0] = alen;
72 :
73 4258585 : uint n = aes_gcm->ares;
74 4258585 : if (n) {
75 0 : while (n && aad_sz) {
76 0 : aes_gcm->Xi.c[n] ^= *(aad++);
77 0 : --aad_sz;
78 0 : n = (n + 1) % 16;
79 0 : }
80 0 : if (n == 0)
81 0 : fd_gcm_gmult( aes_gcm->Xi.u, aes_gcm->Htable );
82 0 : else {
83 0 : aes_gcm->ares = n;
84 0 : return 0;
85 0 : }
86 0 : }
87 4258585 : ulong i;
88 4258585 : if ((i = (aad_sz & (ulong)-16))) {
89 4037865 : fd_gcm_ghash( aes_gcm->Xi.u, aes_gcm->Htable, aad, i );
90 4037865 : aad += i;
91 4037865 : aad_sz -= i;
92 4037865 : }
93 4258585 : if (aad_sz) {
94 4258585 : n = (unsigned int)aad_sz;
95 42276204 : for (i = 0; i < aad_sz; ++i)
96 38017619 : aes_gcm->Xi.c[i] ^= aad[i];
97 4258585 : }
98 :
99 4258585 : aes_gcm->ares = n;
100 4258585 : return 0;
101 4258585 : }
102 :
103 : /* TODO separate reference code and GCM128 */
104 :
105 : static int
106 : fd_gcm128_encrypt( fd_aes_gcm_ref_t * ctx,
107 : uchar const * in,
108 : uchar * out,
109 2129542 : ulong len ) {
110 :
111 2129542 : uint n, ctr, mres;
112 2129542 : ulong i;
113 2129542 : ulong mlen = ctx->len.u[1];
114 2129542 : void *key = &ctx->key;
115 :
116 2129542 : mlen += len;
117 2129542 : if (mlen > ((1UL<<36) - 32) || (sizeof(len) == 8 && mlen < len))
118 0 : return -1;
119 2129542 : ctx->len.u[1] = mlen;
120 :
121 2129542 : mres = ctx->mres;
122 :
123 2129542 : if (ctx->ares) {
124 : /* First call to encrypt finalizes GHASH(AAD) */
125 2129542 : if (len == 0) {
126 2000093 : fd_gcm_gmult( ctx->Xi.u, ctx->Htable );
127 2000093 : ctx->ares = 0;
128 2000093 : return 0;
129 2000093 : }
130 129449 : memcpy(ctx->Xn, ctx->Xi.c, sizeof(ctx->Xi));
131 129449 : ctx->Xi.u[0] = 0;
132 129449 : ctx->Xi.u[1] = 0;
133 129449 : mres = sizeof(ctx->Xi);
134 129449 : ctx->ares = 0;
135 129449 : }
136 :
137 129449 : ctr = fd_uint_bswap( ctx->Yi.d[3] );
138 :
139 129449 : n = mres % 16;
140 103242419 : for (i = 0; i < len; ++i) {
141 103112970 : if (n == 0) {
142 6536143 : fd_aes_encrypt( ctx->Yi.c, ctx->EKi.c, key );
143 6536143 : ++ctr;
144 6536143 : ctx->Yi.d[3] = fd_uint_bswap( ctr );
145 6536143 : }
146 103112970 : ctx->Xn[mres++] = out[i] = in[i] ^ ctx->EKi.c[n];
147 103112970 : n = (n + 1) % 16;
148 103112970 : if (mres == sizeof(ctx->Xn)) {
149 2107943 : fd_gcm_ghash( ctx->Xi.u, ctx->Htable, ctx->Xn, sizeof(ctx->Xn) );
150 2107943 : mres = 0;
151 2107943 : }
152 103112970 : }
153 :
154 129449 : ctx->mres = mres;
155 129449 : return 0;
156 2129542 : }
157 :
158 : static int
159 : fd_gcm128_decrypt( fd_aes_gcm_ref_t * ctx,
160 : uchar const * in,
161 : uchar * out,
162 2129043 : ulong len ) {
163 :
164 2129043 : uint n, ctr, mres;
165 2129043 : ulong i;
166 2129043 : ulong mlen = ctx->len.u[1];
167 2129043 : void * key = &ctx->key;
168 :
169 2129043 : mlen += len;
170 2129043 : if (mlen > ((1UL<<36) - 32) || (sizeof(len) == 8 && mlen < len))
171 0 : return -1;
172 2129043 : ctx->len.u[1] = mlen;
173 :
174 2129043 : mres = ctx->mres;
175 :
176 2129043 : if (ctx->ares) {
177 : /* First call to decrypt finalizes GHASH(AAD) */
178 2129043 : if (len == 0) {
179 2001599 : fd_gcm_gmult( ctx->Xi.u, ctx->Htable );
180 2001599 : ctx->ares = 0;
181 2001599 : return 0;
182 2001599 : }
183 127444 : memcpy(ctx->Xn, ctx->Xi.c, sizeof(ctx->Xi));
184 127444 : ctx->Xi.u[0] = 0;
185 127444 : ctx->Xi.u[1] = 0;
186 127444 : mres = sizeof(ctx->Xi);
187 127444 : ctx->ares = 0;
188 127444 : }
189 :
190 127444 : ctr = fd_uint_bswap( ctx->Yi.d[3] );
191 :
192 127444 : n = mres % 16;
193 103608140 : for (i = 0; i < len; ++i) {
194 103480696 : uchar c;
195 103480696 : if (n == 0) {
196 6554221 : fd_aes_encrypt( ctx->Yi.c, ctx->EKi.c, key );
197 6554221 : ++ctr;
198 6554221 : ctx->Yi.d[3] = fd_uint_bswap( ctr );
199 6554221 : }
200 103480696 : out[i] = (ctx->Xn[mres++] = c = in[i]) ^ ctx->EKi.c[n];
201 103480696 : n = (n + 1) % 16;
202 103480696 : if (mres == sizeof(ctx->Xn)) {
203 2117969 : fd_gcm_ghash( ctx->Xi.u, ctx->Htable, ctx->Xn, sizeof(ctx->Xn) );
204 2117969 : mres = 0;
205 2117969 : }
206 103480696 : }
207 :
208 127444 : ctx->mres = mres;
209 127444 : return 0;
210 2129043 : }
211 :
212 : static void
213 4258585 : fd_gcm128_finish( fd_aes_gcm_ref_t * ctx ) {
214 :
215 4258585 : ulong alen = ctx->len.u[0] << 3; // 176
216 4258585 : ulong clen = ctx->len.u[1] << 3; // 9296
217 :
218 4258585 : struct {
219 4258585 : ulong hi;
220 4258585 : ulong lo;
221 4258585 : } bitlen;
222 4258585 : uint mres = ctx->mres;
223 :
224 4258585 : if( mres ) {
225 256683 : uint blocks = (mres + 15u) & 0xfffffff0u; // 16
226 :
227 256683 : memset(ctx->Xn + mres, 0, blocks - mres);
228 256683 : mres = blocks;
229 256683 : if (mres == sizeof(ctx->Xn)) {
230 183209 : fd_gcm_ghash( ctx->Xi.u, ctx->Htable, ctx->Xn, mres );
231 183209 : mres = 0;
232 183209 : }
233 4001902 : } else if( ctx->ares ) {
234 0 : fd_gcm_gmult( ctx->Xi.u, ctx->Htable );
235 0 : }
236 :
237 4258585 : alen = fd_ulong_bswap( alen );
238 4258585 : clen = fd_ulong_bswap( clen );
239 :
240 4258585 : bitlen.hi = alen;
241 4258585 : bitlen.lo = clen;
242 4258585 : memcpy( ctx->Xn + mres, &bitlen, sizeof(bitlen) );
243 4258585 : mres += (uint)sizeof(bitlen);
244 4258585 : fd_gcm_ghash( ctx->Xi.u, ctx->Htable, ctx->Xn, mres );
245 :
246 4258585 : ctx->Xi.u[0] ^= ctx->EK0.u[0];
247 4258585 : ctx->Xi.u[1] ^= ctx->EK0.u[1];
248 4258585 : }
249 :
250 : void
251 : fd_aes_gcm_encrypt_ref( fd_aes_gcm_ref_t * aes_gcm,
252 : uchar * c,
253 : uchar const * p,
254 : ulong sz,
255 : uchar const * aad,
256 : ulong aad_sz,
257 2129542 : uchar tag[ 16 ] ) {
258 :
259 2129542 : fd_gcm128_aad( aes_gcm, aad, aad_sz );
260 :
261 2129542 : ulong bulk = 0UL;
262 2129542 : assert( 0==fd_gcm128_encrypt( aes_gcm, p+bulk, c+bulk, sz-bulk ) );
263 :
264 : /* CRYPTO_gcm128_tag */
265 2129542 : fd_gcm128_finish( aes_gcm );
266 2129542 : fd_memcpy( tag, aes_gcm->Xi.c, 16 );
267 2129542 : }
268 :
269 : int
270 : fd_aes_gcm_decrypt_ref( fd_aes_gcm_ref_t * aes_gcm,
271 : uchar const * c,
272 : uchar * p,
273 : ulong sz,
274 : uchar const * aad,
275 : ulong aad_sz,
276 2129043 : uchar const tag[ 16 ] ) {
277 :
278 2129043 : fd_gcm128_aad( aes_gcm, aad, aad_sz );
279 :
280 2129043 : ulong bulk = 0UL;
281 2129043 : assert( 0==fd_gcm128_decrypt( aes_gcm, c+bulk, p+bulk, sz-bulk ) );
282 :
283 : /* CRYPTO_gcm128_finish */
284 2129043 : fd_gcm128_finish( aes_gcm );
285 2129043 : return 0==memcmp( aes_gcm->Xi.c, tag, 16 ); /* TODO USE CONSTANT TIME COMPARE */
286 2129043 : }
|