2 * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
11 #include "internal/cryptlib.h"
13 #ifndef OPENSSL_NO_CHACHA
15 # include <openssl/evp.h>
16 # include <openssl/objects.h>
17 # include "evp_locl.h"
18 # include "internal/evp_int.h"
19 # include "internal/chacha.h"
23 double align; /* this ensures even sizeof(EVP_CHACHA_KEY)%8==0 */
24 unsigned int d[CHACHA_KEY_SIZE / 4];
26 unsigned int counter[CHACHA_CTR_SIZE / 4];
27 unsigned char buf[CHACHA_BLK_SIZE];
28 unsigned int partial_len;
31 #define data(ctx) ((EVP_CHACHA_KEY *)(ctx)->cipher_data)
33 static int chacha_init_key(EVP_CIPHER_CTX *ctx,
34 const unsigned char user_key[CHACHA_KEY_SIZE],
35 const unsigned char iv[CHACHA_CTR_SIZE], int enc)
37 EVP_CHACHA_KEY *key = data(ctx);
41 for (i = 0; i < CHACHA_KEY_SIZE; i+=4) {
42 key->key.d[i/4] = CHACHA_U8TOU32(user_key+i);
46 for (i = 0; i < CHACHA_CTR_SIZE; i+=4) {
47 key->counter[i/4] = CHACHA_U8TOU32(iv+i);
55 static int chacha_cipher(EVP_CIPHER_CTX * ctx, unsigned char *out,
56 const unsigned char *inp, size_t len)
58 EVP_CHACHA_KEY *key = data(ctx);
59 unsigned int n, rem, ctr32;
61 if ((n = key->partial_len)) {
62 while (len && n < CHACHA_BLK_SIZE) {
63 *out++ = *inp++ ^ key->buf[n++];
71 if (n == CHACHA_BLK_SIZE) {
74 if (key->counter[0] == 0)
79 rem = (unsigned int)(len % CHACHA_BLK_SIZE);
81 ctr32 = key->counter[0];
82 while (len >= CHACHA_BLK_SIZE) {
83 size_t blocks = len / CHACHA_BLK_SIZE;
85 * 1<<28 is just a not-so-small yet not-so-large number...
86 * Below condition is practically never met, but it has to
87 * be checked for code correctness.
89 if (sizeof(size_t)>sizeof(unsigned int) && blocks>(1U<<28))
93 * As ChaCha20_ctr32 operates on 32-bit counter, caller
94 * has to handle overflow. 'if' below detects the
95 * overflow, which is then handled by limiting the
96 * amount of blocks to the exact overflow point...
98 ctr32 += (unsigned int)blocks;
103 blocks *= CHACHA_BLK_SIZE;
104 ChaCha20_ctr32(out, inp, blocks, key->key.d, key->counter);
109 key->counter[0] = ctr32;
110 if (ctr32 == 0) key->counter[1]++;
114 memset(key->buf, 0, sizeof(key->buf));
115 ChaCha20_ctr32(key->buf, key->buf, CHACHA_BLK_SIZE,
116 key->key.d, key->counter);
117 for (n = 0; n < rem; n++)
118 out[n] = inp[n] ^ key->buf[n];
119 key->partial_len = rem;
125 static const EVP_CIPHER chacha20 = {
128 CHACHA_KEY_SIZE, /* key_len */
129 CHACHA_CTR_SIZE, /* iv_len, 128-bit counter in the context */
130 EVP_CIPH_CUSTOM_IV | EVP_CIPH_ALWAYS_CALL_INIT,
134 sizeof(EVP_CHACHA_KEY),
141 const EVP_CIPHER *EVP_chacha20(void)
146 # ifndef OPENSSL_NO_POLY1305
147 # include "internal/poly1305.h"
151 unsigned int nonce[12/4];
152 unsigned char tag[POLY1305_BLOCK_SIZE];
153 unsigned char tls_aad[POLY1305_BLOCK_SIZE];
154 struct { uint64_t aad, text; } len;
155 int aad, mac_inited, tag_len, nonce_len;
156 size_t tls_payload_length;
157 } EVP_CHACHA_AEAD_CTX;
159 # define NO_TLS_PAYLOAD_LENGTH ((size_t)-1)
160 # define aead_data(ctx) ((EVP_CHACHA_AEAD_CTX *)(ctx)->cipher_data)
161 # define POLY1305_ctx(actx) ((POLY1305 *)(actx + 1))
163 static int chacha20_poly1305_init_key(EVP_CIPHER_CTX *ctx,
164 const unsigned char *inkey,
165 const unsigned char *iv, int enc)
167 EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
175 actx->mac_inited = 0;
176 actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
179 unsigned char temp[CHACHA_CTR_SIZE] = { 0 };
181 /* pad on the left */
182 if (actx->nonce_len <= CHACHA_CTR_SIZE)
183 memcpy(temp + CHACHA_CTR_SIZE - actx->nonce_len, iv,
186 chacha_init_key(ctx, inkey, temp, enc);
188 actx->nonce[0] = actx->key.counter[1];
189 actx->nonce[1] = actx->key.counter[2];
190 actx->nonce[2] = actx->key.counter[3];
192 chacha_init_key(ctx, inkey, NULL, enc);
198 # if !defined(OPENSSL_SMALL_FOOTPRINT)
200 # if defined(POLY1305_ASM) && (defined(__x86_64) || defined(__x86_64__) || \
201 defined(_M_AMD64) || defined(_M_X64))
202 # define XOR128_HELPERS
203 void *xor128_encrypt_n_pad(void *out, const void *inp, void *otp, size_t len);
204 void *xor128_decrypt_n_pad(void *out, const void *inp, void *otp, size_t len);
205 static const unsigned char zero[4 * CHACHA_BLK_SIZE] = { 0 };
207 static const unsigned char zero[2 * CHACHA_BLK_SIZE] = { 0 };
210 static int chacha20_poly1305_tls_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
211 const unsigned char *in, size_t len)
213 EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
214 size_t tail, tohash_len, buf_len, plen = actx->tls_payload_length;
215 unsigned char *buf, *tohash, *ctr, storage[sizeof(zero) + 32];
217 if (len != plen + POLY1305_BLOCK_SIZE)
220 buf = storage + ((0 - (size_t)storage) & 15); /* align */
221 ctr = buf + CHACHA_BLK_SIZE;
222 tohash = buf + CHACHA_BLK_SIZE - POLY1305_BLOCK_SIZE;
224 # ifdef XOR128_HELPERS
225 if (plen <= 3 * CHACHA_BLK_SIZE) {
226 actx->key.counter[0] = 0;
227 buf_len = (plen + 2 * CHACHA_BLK_SIZE - 1) & (0 - CHACHA_BLK_SIZE);
228 ChaCha20_ctr32(buf, zero, buf_len, actx->key.key.d,
230 Poly1305_Init(POLY1305_ctx(actx), buf);
231 actx->key.partial_len = 0;
232 memcpy(tohash, actx->tls_aad, POLY1305_BLOCK_SIZE);
233 tohash_len = POLY1305_BLOCK_SIZE;
234 actx->len.aad = EVP_AEAD_TLS1_AAD_LEN;
235 actx->len.text = plen;
239 ctr = xor128_encrypt_n_pad(out, in, ctr, plen);
241 ctr = xor128_decrypt_n_pad(out, in, ctr, plen);
245 tohash_len = (size_t)(ctr - tohash);
249 if (plen <= CHACHA_BLK_SIZE) {
252 actx->key.counter[0] = 0;
253 ChaCha20_ctr32(buf, zero, (buf_len = 2 * CHACHA_BLK_SIZE),
254 actx->key.key.d, actx->key.counter);
255 Poly1305_Init(POLY1305_ctx(actx), buf);
256 actx->key.partial_len = 0;
257 memcpy(tohash, actx->tls_aad, POLY1305_BLOCK_SIZE);
258 tohash_len = POLY1305_BLOCK_SIZE;
259 actx->len.aad = EVP_AEAD_TLS1_AAD_LEN;
260 actx->len.text = plen;
263 for (i = 0; i < plen; i++) {
264 out[i] = ctr[i] ^= in[i];
267 for (i = 0; i < plen; i++) {
268 unsigned char c = in[i];
277 tail = (0 - i) & (POLY1305_BLOCK_SIZE - 1);
278 memset(ctr + i, 0, tail);
280 tohash_len += i + tail;
284 actx->key.counter[0] = 0;
285 ChaCha20_ctr32(buf, zero, (buf_len = CHACHA_BLK_SIZE),
286 actx->key.key.d, actx->key.counter);
287 Poly1305_Init(POLY1305_ctx(actx), buf);
288 actx->key.counter[0] = 1;
289 actx->key.partial_len = 0;
290 Poly1305_Update(POLY1305_ctx(actx), actx->tls_aad, POLY1305_BLOCK_SIZE);
293 actx->len.aad = EVP_AEAD_TLS1_AAD_LEN;
294 actx->len.text = plen;
297 ChaCha20_ctr32(out, in, plen, actx->key.key.d, actx->key.counter);
298 Poly1305_Update(POLY1305_ctx(actx), out, plen);
300 Poly1305_Update(POLY1305_ctx(actx), in, plen);
301 ChaCha20_ctr32(out, in, plen, actx->key.key.d, actx->key.counter);
306 tail = (0 - plen) & (POLY1305_BLOCK_SIZE - 1);
307 Poly1305_Update(POLY1305_ctx(actx), zero, tail);
316 if (is_endian.little) {
317 memcpy(ctr, (unsigned char *)&actx->len, POLY1305_BLOCK_SIZE);
319 ctr[0] = (unsigned char)(actx->len.aad);
320 ctr[1] = (unsigned char)(actx->len.aad>>8);
321 ctr[2] = (unsigned char)(actx->len.aad>>16);
322 ctr[3] = (unsigned char)(actx->len.aad>>24);
323 ctr[4] = (unsigned char)(actx->len.aad>>32);
324 ctr[5] = (unsigned char)(actx->len.aad>>40);
325 ctr[6] = (unsigned char)(actx->len.aad>>48);
326 ctr[7] = (unsigned char)(actx->len.aad>>56);
328 ctr[8] = (unsigned char)(actx->len.text);
329 ctr[9] = (unsigned char)(actx->len.text>>8);
330 ctr[10] = (unsigned char)(actx->len.text>>16);
331 ctr[11] = (unsigned char)(actx->len.text>>24);
332 ctr[12] = (unsigned char)(actx->len.text>>32);
333 ctr[13] = (unsigned char)(actx->len.text>>40);
334 ctr[14] = (unsigned char)(actx->len.text>>48);
335 ctr[15] = (unsigned char)(actx->len.text>>56);
337 tohash_len += POLY1305_BLOCK_SIZE;
340 Poly1305_Update(POLY1305_ctx(actx), tohash, tohash_len);
341 OPENSSL_cleanse(buf, buf_len);
342 Poly1305_Final(POLY1305_ctx(actx), ctx->encrypt ? actx->tag
345 actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
348 memcpy(out, actx->tag, POLY1305_BLOCK_SIZE);
350 if (CRYPTO_memcmp(tohash, in, POLY1305_BLOCK_SIZE)) {
351 memset(out - (len - POLY1305_BLOCK_SIZE), 0,
352 len - POLY1305_BLOCK_SIZE);
360 static const unsigned char zero[CHACHA_BLK_SIZE] = { 0 };
363 static int chacha20_poly1305_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
364 const unsigned char *in, size_t len)
366 EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
367 size_t rem, plen = actx->tls_payload_length;
369 if (!actx->mac_inited) {
370 # if !defined(OPENSSL_SMALL_FOOTPRINT)
371 if (plen != NO_TLS_PAYLOAD_LENGTH && out != NULL)
372 return chacha20_poly1305_tls_cipher(ctx, out, in, len);
374 actx->key.counter[0] = 0;
375 ChaCha20_ctr32(actx->key.buf, zero, CHACHA_BLK_SIZE,
376 actx->key.key.d, actx->key.counter);
377 Poly1305_Init(POLY1305_ctx(actx), actx->key.buf);
378 actx->key.counter[0] = 1;
379 actx->key.partial_len = 0;
380 actx->len.aad = actx->len.text = 0;
381 actx->mac_inited = 1;
382 if (plen != NO_TLS_PAYLOAD_LENGTH) {
383 Poly1305_Update(POLY1305_ctx(actx), actx->tls_aad,
384 EVP_AEAD_TLS1_AAD_LEN);
385 actx->len.aad = EVP_AEAD_TLS1_AAD_LEN;
390 if (in) { /* aad or text */
391 if (out == NULL) { /* aad */
392 Poly1305_Update(POLY1305_ctx(actx), in, len);
393 actx->len.aad += len;
396 } else { /* plain- or ciphertext */
397 if (actx->aad) { /* wrap up aad */
398 if ((rem = (size_t)actx->len.aad % POLY1305_BLOCK_SIZE))
399 Poly1305_Update(POLY1305_ctx(actx), zero,
400 POLY1305_BLOCK_SIZE - rem);
404 actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
405 if (plen == NO_TLS_PAYLOAD_LENGTH)
407 else if (len != plen + POLY1305_BLOCK_SIZE)
410 if (ctx->encrypt) { /* plaintext */
411 chacha_cipher(ctx, out, in, plen);
412 Poly1305_Update(POLY1305_ctx(actx), out, plen);
415 actx->len.text += plen;
416 } else { /* ciphertext */
417 Poly1305_Update(POLY1305_ctx(actx), in, plen);
418 chacha_cipher(ctx, out, in, plen);
421 actx->len.text += plen;
425 if (in == NULL /* explicit final */
426 || plen != len) { /* or tls mode */
431 unsigned char temp[POLY1305_BLOCK_SIZE];
433 if (actx->aad) { /* wrap up aad */
434 if ((rem = (size_t)actx->len.aad % POLY1305_BLOCK_SIZE))
435 Poly1305_Update(POLY1305_ctx(actx), zero,
436 POLY1305_BLOCK_SIZE - rem);
440 if ((rem = (size_t)actx->len.text % POLY1305_BLOCK_SIZE))
441 Poly1305_Update(POLY1305_ctx(actx), zero,
442 POLY1305_BLOCK_SIZE - rem);
444 if (is_endian.little) {
445 Poly1305_Update(POLY1305_ctx(actx),
446 (unsigned char *)&actx->len, POLY1305_BLOCK_SIZE);
448 temp[0] = (unsigned char)(actx->len.aad);
449 temp[1] = (unsigned char)(actx->len.aad>>8);
450 temp[2] = (unsigned char)(actx->len.aad>>16);
451 temp[3] = (unsigned char)(actx->len.aad>>24);
452 temp[4] = (unsigned char)(actx->len.aad>>32);
453 temp[5] = (unsigned char)(actx->len.aad>>40);
454 temp[6] = (unsigned char)(actx->len.aad>>48);
455 temp[7] = (unsigned char)(actx->len.aad>>56);
457 temp[8] = (unsigned char)(actx->len.text);
458 temp[9] = (unsigned char)(actx->len.text>>8);
459 temp[10] = (unsigned char)(actx->len.text>>16);
460 temp[11] = (unsigned char)(actx->len.text>>24);
461 temp[12] = (unsigned char)(actx->len.text>>32);
462 temp[13] = (unsigned char)(actx->len.text>>40);
463 temp[14] = (unsigned char)(actx->len.text>>48);
464 temp[15] = (unsigned char)(actx->len.text>>56);
466 Poly1305_Update(POLY1305_ctx(actx), temp, POLY1305_BLOCK_SIZE);
468 Poly1305_Final(POLY1305_ctx(actx), ctx->encrypt ? actx->tag
470 actx->mac_inited = 0;
472 if (in != NULL && len != plen) { /* tls mode */
474 memcpy(out, actx->tag, POLY1305_BLOCK_SIZE);
476 if (CRYPTO_memcmp(temp, in, POLY1305_BLOCK_SIZE)) {
477 memset(out - plen, 0, plen);
482 else if (!ctx->encrypt) {
483 if (CRYPTO_memcmp(temp, actx->tag, actx->tag_len))
490 static int chacha20_poly1305_cleanup(EVP_CIPHER_CTX *ctx)
492 EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
494 OPENSSL_cleanse(ctx->cipher_data, sizeof(*actx) + Poly1305_ctx_size());
498 static int chacha20_poly1305_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg,
501 EVP_CHACHA_AEAD_CTX *actx = aead_data(ctx);
506 actx = ctx->cipher_data
507 = OPENSSL_zalloc(sizeof(*actx) + Poly1305_ctx_size());
509 EVPerr(EVP_F_CHACHA20_POLY1305_CTRL, EVP_R_INITIALIZATION_ERROR);
515 actx->mac_inited = 0;
517 actx->nonce_len = 12;
518 actx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
519 memset(actx->tls_aad, 0, POLY1305_BLOCK_SIZE);
524 EVP_CIPHER_CTX *dst = (EVP_CIPHER_CTX *)ptr;
527 OPENSSL_memdup(actx, sizeof(*actx) + Poly1305_ctx_size());
528 if (dst->cipher_data == NULL) {
529 EVPerr(EVP_F_CHACHA20_POLY1305_CTRL, EVP_R_COPY_ERROR);
535 case EVP_CTRL_AEAD_SET_IVLEN:
536 if (arg <= 0 || arg > CHACHA_CTR_SIZE)
538 actx->nonce_len = arg;
541 case EVP_CTRL_AEAD_SET_IV_FIXED:
544 actx->nonce[0] = actx->key.counter[1]
545 = CHACHA_U8TOU32((unsigned char *)ptr);
546 actx->nonce[1] = actx->key.counter[2]
547 = CHACHA_U8TOU32((unsigned char *)ptr+4);
548 actx->nonce[2] = actx->key.counter[3]
549 = CHACHA_U8TOU32((unsigned char *)ptr+8);
552 case EVP_CTRL_AEAD_SET_TAG:
553 if (arg <= 0 || arg > POLY1305_BLOCK_SIZE)
556 memcpy(actx->tag, ptr, arg);
561 case EVP_CTRL_AEAD_GET_TAG:
562 if (arg <= 0 || arg > POLY1305_BLOCK_SIZE || !ctx->encrypt)
564 memcpy(ptr, actx->tag, arg);
567 case EVP_CTRL_AEAD_TLS1_AAD:
568 if (arg != EVP_AEAD_TLS1_AAD_LEN)
572 unsigned char *aad = ptr;
574 memcpy(actx->tls_aad, ptr, EVP_AEAD_TLS1_AAD_LEN);
575 len = aad[EVP_AEAD_TLS1_AAD_LEN - 2] << 8 |
576 aad[EVP_AEAD_TLS1_AAD_LEN - 1];
579 if (len < POLY1305_BLOCK_SIZE)
581 len -= POLY1305_BLOCK_SIZE; /* discount attached tag */
582 aad[EVP_AEAD_TLS1_AAD_LEN - 2] = (unsigned char)(len >> 8);
583 aad[EVP_AEAD_TLS1_AAD_LEN - 1] = (unsigned char)len;
585 actx->tls_payload_length = len;
588 * merge record sequence number as per RFC7905
590 actx->key.counter[1] = actx->nonce[0];
591 actx->key.counter[2] = actx->nonce[1] ^ CHACHA_U8TOU32(aad);
592 actx->key.counter[3] = actx->nonce[2] ^ CHACHA_U8TOU32(aad+4);
593 actx->mac_inited = 0;
595 return POLY1305_BLOCK_SIZE; /* tag length */
598 case EVP_CTRL_AEAD_SET_MAC_KEY:
607 static EVP_CIPHER chacha20_poly1305 = {
608 NID_chacha20_poly1305,
610 CHACHA_KEY_SIZE, /* key_len */
611 12, /* iv_len, 96-bit nonce in the context */
612 EVP_CIPH_FLAG_AEAD_CIPHER | EVP_CIPH_CUSTOM_IV |
613 EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT |
614 EVP_CIPH_CUSTOM_COPY | EVP_CIPH_FLAG_CUSTOM_CIPHER,
615 chacha20_poly1305_init_key,
616 chacha20_poly1305_cipher,
617 chacha20_poly1305_cleanup,
618 0, /* 0 moves context-specific structure allocation to ctrl */
619 NULL, /* set_asn1_parameters */
620 NULL, /* get_asn1_parameters */
621 chacha20_poly1305_ctrl,
625 const EVP_CIPHER *EVP_chacha20_poly1305(void)
627 return(&chacha20_poly1305);