git.samba.org - gd/nettle/blob - chacha-poly1305.c

   1 /* chacha-poly1305.c
   2
   3    AEAD mechanism based on chacha and poly1305.
   4
   5    Copyright (C) 2014, 2015 Niels Möller
   6
   7    This file is part of GNU Nettle.
   8
   9    GNU Nettle is free software: you can redistribute it and/or
  10    modify it under the terms of either:
  11
  12      * the GNU Lesser General Public License as published by the Free
  13        Software Foundation; either version 3 of the License, or (at your
  14        option) any later version.
  15
  16    or
  17
  18      * the GNU General Public License as published by the Free
  19        Software Foundation; either version 2 of the License, or (at your
  20        option) any later version.
  21
  22    or both in parallel, as here.
  23
  24    GNU Nettle is distributed in the hope that it will be useful,
  25    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27    General Public License for more details.
  28
  29    You should have received copies of the GNU General Public License and
  30    the GNU Lesser General Public License along with this program.  If
  31    not, see http://www.gnu.org/licenses/.
  32 */
  33
  34 /* This implements chacha-poly1305 according to
  35    draft-irtf-cfrg-chacha20-poly1305-08. The inputs to poly1305 are:
  36
  37      associated data
  38      zero padding
  39      ciphertext
  40      zero padding
  41      length of associated data (64-bit, little endian)
  42      length of ciphertext (64-bit, little endian)
  43
  44    where the padding fields are 0-15 zero bytes, filling up to a
  45    16-byte boundary.
  46 */
  47
  48 #if HAVE_CONFIG_H
  49 # include "config.h"
  50 #endif
  51
  52 #include <assert.h>
  53 #include <string.h>
  54
  55 #include "chacha-internal.h"
  56 #include "chacha-poly1305.h"
  57
  58 #include "macros.h"
  59
  60 #define CHACHA_ROUNDS 20
  61
  62 /* FIXME: Also set nonce to zero, and implement nonce
  63    auto-increment? */
  64 void
  65 chacha_poly1305_set_key (struct chacha_poly1305_ctx *ctx,
  66                          const uint8_t *key)
  67 {
  68   chacha_set_key (&ctx->chacha, key);
  69 }
  70
  71 void
  72 chacha_poly1305_set_nonce (struct chacha_poly1305_ctx *ctx,
  73                            const uint8_t *nonce)
  74 {
  75   union {
  76     uint32_t x[_CHACHA_STATE_LENGTH];
  77     uint8_t subkey[32];
  78   } u;
  79
  80   chacha_set_nonce96 (&ctx->chacha, nonce);
  81   /* Generate authentication key */
  82   _chacha_core (u.x, ctx->chacha.state, CHACHA_ROUNDS);
  83   poly1305_set_key (&ctx->poly1305, u.subkey);
  84   /* For final poly1305 processing */
  85   memcpy (ctx->s.b, u.subkey + 16, 16);
  86   /* Increment block count */
  87   ctx->chacha.state[12] = 1;
  88
  89   ctx->auth_size = ctx->data_size = ctx->index = 0;
  90 }
  91
  92 /* FIXME: Duplicated in poly1305-aes128.c */
  93 #define COMPRESS(ctx, data) _poly1305_block(&(ctx)->poly1305, (data), 1)
  94
  95 static void
  96 poly1305_update (struct chacha_poly1305_ctx *ctx,
  97                  size_t length, const uint8_t *data)
  98 {
  99   MD_UPDATE (ctx, length, data, COMPRESS, (void) 0);
 100 }
 101
 102 static void
 103 poly1305_pad (struct chacha_poly1305_ctx *ctx)
 104 {
 105   if (ctx->index)
 106     {
 107       memset (ctx->block + ctx->index, 0,
 108               POLY1305_BLOCK_SIZE - ctx->index);
 109       _poly1305_block(&ctx->poly1305, ctx->block, 1);
 110       ctx->index = 0;
 111     }
 112 }
 113 void
 114 chacha_poly1305_update (struct chacha_poly1305_ctx *ctx,
 115                         size_t length, const uint8_t *data)
 116 {
 117   assert (ctx->data_size == 0);
 118   poly1305_update (ctx, length, data);
 119   ctx->auth_size += length;
 120 }
 121
 122
 123 void
 124 chacha_poly1305_encrypt (struct chacha_poly1305_ctx *ctx,
 125                          size_t length, uint8_t *dst, const uint8_t *src)
 126 {
 127   if (!length)
 128     return;
 129
 130   assert (ctx->data_size % CHACHA_POLY1305_BLOCK_SIZE == 0);
 131   poly1305_pad (ctx);
 132
 133   chacha_crypt (&ctx->chacha, length, dst, src);
 134   poly1305_update (ctx, length, dst);
 135   ctx->data_size += length;
 136 }
 137
 138 void
 139 chacha_poly1305_decrypt (struct chacha_poly1305_ctx *ctx,
 140                          size_t length, uint8_t *dst, const uint8_t *src)
 141 {
 142   if (!length)
 143     return;
 144
 145   assert (ctx->data_size % CHACHA_POLY1305_BLOCK_SIZE == 0);
 146   poly1305_pad (ctx);
 147
 148   poly1305_update (ctx, length, src);
 149   chacha_crypt (&ctx->chacha, length, dst, src);
 150   ctx->data_size += length;
 151 }
 152
 153 void
 154 chacha_poly1305_digest (struct chacha_poly1305_ctx *ctx,
 155                         size_t length, uint8_t *digest)
 156 {
 157   uint8_t buf[16];
 158
 159   poly1305_pad (ctx);
 160   LE_WRITE_UINT64 (buf, ctx->auth_size);
 161   LE_WRITE_UINT64 (buf + 8, ctx->data_size);
 162
 163   _poly1305_block (&ctx->poly1305, buf, 1);
 164
 165   poly1305_digest (&ctx->poly1305, &ctx->s);
 166   memcpy (digest, &ctx->s.b, length);
 167 }