cipher/cipher-ccm.c

   1 /* cipher-ccm.c - CTR mode with CBC-MAC mode implementation
   2  * Copyright (C) 2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
   3  *
   4  * This file is part of Libgcrypt.
   5  *
   6  * Libgcrypt is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU Lesser general Public License as
   8  * published by the Free Software Foundation; either version 2.1 of
   9  * the License, or (at your option) any later version.
  10  *
  11  * Libgcrypt is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <config.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <errno.h>
  25
  26 #include "g10lib.h"
  27 #include "cipher.h"
  28 #include "bufhelp.h"
  29 #include "./cipher-internal.h"
  30
  31
  32 #define set_burn(burn, nburn) do { \
  33   unsigned int __nburn = (nburn); \
  34   (burn) = (burn) > __nburn ? (burn) : __nburn; } while (0)
  35
  36
  37 static unsigned int
  38 do_cbc_mac (gcry_cipher_hd_t c, const unsigned char *inbuf, size_t inlen,
  39             int do_padding)
  40 {
  41   const unsigned int blocksize = 16;
  42   gcry_cipher_encrypt_t enc_fn = c->spec->encrypt;
  43   unsigned char tmp[blocksize];
  44   unsigned int burn = 0;
  45   unsigned int unused = c->u_mode.ccm.mac_unused;
  46   size_t nblocks;
  47
  48   if (inlen == 0 && (unused == 0 || !do_padding))
  49     return 0;
  50
  51   do
  52     {
  53       if (inlen + unused < blocksize || unused > 0)
  54         {
  55           for (; inlen && unused < blocksize; inlen--)
  56             c->u_mode.ccm.macbuf[unused++] = *inbuf++;
  57         }
  58       if (!inlen)
  59         {
  60           if (!do_padding)
  61             break;
  62
  63           while (unused < blocksize)
  64             c->u_mode.ccm.macbuf[unused++] = 0;
  65         }
  66
  67       if (unused > 0)
  68         {
  69           /* Process one block from macbuf.  */
  70           cipher_block_xor(c->u_iv.iv, c->u_iv.iv, c->u_mode.ccm.macbuf,
  71                            blocksize);
  72           set_burn (burn, enc_fn ( &c->context.c, c->u_iv.iv, c->u_iv.iv ));
  73
  74           unused = 0;
  75         }
  76
  77       if (c->bulk.cbc_enc)
  78         {
  79           nblocks = inlen / blocksize;
  80           c->bulk.cbc_enc (&c->context.c, c->u_iv.iv, tmp, inbuf, nblocks, 1);
  81           inbuf += nblocks * blocksize;
  82           inlen -= nblocks * blocksize;
  83
  84           wipememory (tmp, sizeof(tmp));
  85         }
  86       else
  87         {
  88           while (inlen >= blocksize)
  89             {
  90               cipher_block_xor(c->u_iv.iv, c->u_iv.iv, inbuf, blocksize);
  91
  92               set_burn (burn, enc_fn ( &c->context.c, c->u_iv.iv, c->u_iv.iv ));
  93
  94               inlen -= blocksize;
  95               inbuf += blocksize;
  96             }
  97         }
  98     }
  99   while (inlen > 0);
 100
 101   c->u_mode.ccm.mac_unused = unused;
 102
 103   if (burn)
 104     burn += 4 * sizeof(void *);
 105
 106   return burn;
 107 }
 108
 109
 110 gcry_err_code_t
 111 _gcry_cipher_ccm_set_nonce (gcry_cipher_hd_t c, const unsigned char *nonce,
 112                             size_t noncelen)
 113 {
 114   unsigned int marks_key;
 115   size_t L = 15 - noncelen;
 116   size_t L_;
 117
 118   L_ = L - 1;
 119
 120   if (!nonce)
 121     return GPG_ERR_INV_ARG;
 122   /* Length field must be 2, 3, ..., or 8. */
 123   if (L < 2 || L > 8)
 124     return GPG_ERR_INV_LENGTH;
 125
 126   /* Reset state */
 127   marks_key = c->marks.key;
 128   memset (&c->u_mode, 0, sizeof(c->u_mode));
 129   memset (&c->marks, 0, sizeof(c->marks));
 130   memset (&c->u_iv, 0, sizeof(c->u_iv));
 131   memset (&c->u_ctr, 0, sizeof(c->u_ctr));
 132   memset (c->lastiv, 0, sizeof(c->lastiv));
 133   c->unused = 0;
 134   c->marks.key = marks_key;
 135
 136   /* Setup CTR */
 137   c->u_ctr.ctr[0] = L_;
 138   memcpy (&c->u_ctr.ctr[1], nonce, noncelen);
 139   memset (&c->u_ctr.ctr[1 + noncelen], 0, L);
 140
 141   /* Setup IV */
 142   c->u_iv.iv[0] = L_;
 143   memcpy (&c->u_iv.iv[1], nonce, noncelen);
 144   /* Add (8 * M_ + 64 * flags) to iv[0] and set iv[noncelen + 1 ... 15] later
 145      in set_aad.  */
 146   memset (&c->u_iv.iv[1 + noncelen], 0, L);
 147
 148   c->u_mode.ccm.nonce = 1;
 149
 150   return GPG_ERR_NO_ERROR;
 151 }
 152
 153
 154 gcry_err_code_t
 155 _gcry_cipher_ccm_set_lengths (gcry_cipher_hd_t c, u64 encryptlen, u64 aadlen,
 156                               u64 taglen)
 157 {
 158   unsigned int burn = 0;
 159   unsigned char b0[16];
 160   size_t noncelen = 15 - (c->u_iv.iv[0] + 1);
 161   u64 M = taglen;
 162   u64 M_;
 163   int i;
 164
 165   M_ = (M - 2) / 2;
 166
 167   /* Authentication field must be 4, 6, 8, 10, 12, 14 or 16. */
 168   if ((M_ * 2 + 2) != M || M < 4 || M > 16)
 169     return GPG_ERR_INV_LENGTH;
 170   if (!c->u_mode.ccm.nonce || c->marks.tag)
 171     return GPG_ERR_INV_STATE;
 172   if (c->u_mode.ccm.lengths)
 173     return GPG_ERR_INV_STATE;
 174
 175   c->u_mode.ccm.authlen = taglen;
 176   c->u_mode.ccm.encryptlen = encryptlen;
 177   c->u_mode.ccm.aadlen = aadlen;
 178
 179   /* Complete IV setup.  */
 180   c->u_iv.iv[0] += (aadlen > 0) * 64 + M_ * 8;
 181   for (i = 16 - 1; i >= 1 + noncelen; i--)
 182     {
 183       c->u_iv.iv[i] = encryptlen & 0xff;
 184       encryptlen >>= 8;
 185     }
 186
 187   memcpy (b0, c->u_iv.iv, 16);
 188   memset (c->u_iv.iv, 0, 16);
 189
 190   set_burn (burn, do_cbc_mac (c, b0, 16, 0));
 191
 192   if (aadlen == 0)
 193     {
 194       /* Do nothing.  */
 195     }
 196   else if (aadlen > 0 && aadlen <= (unsigned int)0xfeff)
 197     {
 198       b0[0] = (aadlen >> 8) & 0xff;
 199       b0[1] = aadlen & 0xff;
 200       set_burn (burn, do_cbc_mac (c, b0, 2, 0));
 201     }
 202   else if (aadlen > 0xfeff && aadlen <= (unsigned int)0xffffffff)
 203     {
 204       b0[0] = 0xff;
 205       b0[1] = 0xfe;
 206       buf_put_be32(&b0[2], aadlen);
 207       set_burn (burn, do_cbc_mac (c, b0, 6, 0));
 208     }
 209   else if (aadlen > (unsigned int)0xffffffff)
 210     {
 211       b0[0] = 0xff;
 212       b0[1] = 0xff;
 213       buf_put_be64(&b0[2], aadlen);
 214       set_burn (burn, do_cbc_mac (c, b0, 10, 0));
 215     }
 216
 217   /* Generate S_0 and increase counter.  */
 218   set_burn (burn, c->spec->encrypt ( &c->context.c, c->u_mode.ccm.s0,
 219                                      c->u_ctr.ctr ));
 220   c->u_ctr.ctr[15]++;
 221
 222   if (burn)
 223     _gcry_burn_stack (burn + sizeof(void *) * 5);
 224
 225   c->u_mode.ccm.lengths = 1;
 226
 227   return GPG_ERR_NO_ERROR;
 228 }
 229
 230
 231 gcry_err_code_t
 232 _gcry_cipher_ccm_authenticate (gcry_cipher_hd_t c, const unsigned char *abuf,
 233                                size_t abuflen)
 234 {
 235   unsigned int burn;
 236
 237   if (abuflen > 0 && !abuf)
 238     return GPG_ERR_INV_ARG;
 239   if (!c->u_mode.ccm.nonce || !c->u_mode.ccm.lengths || c->marks.tag)
 240     return GPG_ERR_INV_STATE;
 241   if (abuflen > c->u_mode.ccm.aadlen)
 242     return GPG_ERR_INV_LENGTH;
 243
 244   c->u_mode.ccm.aadlen -= abuflen;
 245   burn = do_cbc_mac (c, abuf, abuflen, c->u_mode.ccm.aadlen == 0);
 246
 247   if (burn)
 248     _gcry_burn_stack (burn + sizeof(void *) * 5);
 249
 250   return GPG_ERR_NO_ERROR;
 251 }
 252
 253
 254 gcry_err_code_t
 255 _gcry_cipher_ccm_tag (gcry_cipher_hd_t c, unsigned char *outbuf,
 256                       size_t outbuflen, int check)
 257 {
 258   unsigned int burn;
 259
 260   if (!outbuf || outbuflen == 0)
 261     return GPG_ERR_INV_ARG;
 262   /* Tag length must be same as initial authlen.  */
 263   if (c->u_mode.ccm.authlen != outbuflen)
 264     return GPG_ERR_INV_LENGTH;
 265   if (!c->u_mode.ccm.nonce || !c->u_mode.ccm.lengths || c->u_mode.ccm.aadlen > 0)
 266     return GPG_ERR_INV_STATE;
 267   /* Initial encrypt length must match with length of actual data processed.  */
 268   if (c->u_mode.ccm.encryptlen > 0)
 269     return GPG_ERR_UNFINISHED;
 270
 271   if (!c->marks.tag)
 272     {
 273       burn = do_cbc_mac (c, NULL, 0, 1); /* Perform final padding.  */
 274
 275       /* Add S_0 */
 276       cipher_block_xor (c->u_iv.iv, c->u_iv.iv, c->u_mode.ccm.s0, 16);
 277
 278       wipememory (c->u_ctr.ctr, 16);
 279       wipememory (c->u_mode.ccm.s0, 16);
 280       wipememory (c->u_mode.ccm.macbuf, 16);
 281
 282       if (burn)
 283         _gcry_burn_stack (burn + sizeof(void *) * 5);
 284
 285       c->marks.tag = 1;
 286     }
 287
 288   if (!check)
 289     {
 290       memcpy (outbuf, c->u_iv.iv, outbuflen);
 291       return GPG_ERR_NO_ERROR;
 292     }
 293   else
 294     {
 295       return buf_eq_const(outbuf, c->u_iv.iv, outbuflen) ?
 296              GPG_ERR_NO_ERROR : GPG_ERR_CHECKSUM;
 297     }
 298 }
 299
 300
 301 gcry_err_code_t
 302 _gcry_cipher_ccm_get_tag (gcry_cipher_hd_t c, unsigned char *outtag,
 303                           size_t taglen)
 304 {
 305   return _gcry_cipher_ccm_tag (c, outtag, taglen, 0);
 306 }
 307
 308
 309 gcry_err_code_t
 310 _gcry_cipher_ccm_check_tag (gcry_cipher_hd_t c, const unsigned char *intag,
 311                             size_t taglen)
 312 {
 313   return _gcry_cipher_ccm_tag (c, (unsigned char *)intag, taglen, 1);
 314 }
 315
 316
 317 gcry_err_code_t
 318 _gcry_cipher_ccm_encrypt (gcry_cipher_hd_t c, unsigned char *outbuf,
 319                           size_t outbuflen, const unsigned char *inbuf,
 320                           size_t inbuflen)
 321 {
 322   unsigned int burn;
 323
 324   if (outbuflen < inbuflen)
 325     return GPG_ERR_BUFFER_TOO_SHORT;
 326   if (!c->u_mode.ccm.nonce || c->marks.tag || !c->u_mode.ccm.lengths ||
 327       c->u_mode.ccm.aadlen > 0)
 328     return GPG_ERR_INV_STATE;
 329   if (inbuflen > c->u_mode.ccm.encryptlen)
 330     return GPG_ERR_INV_LENGTH;
 331
 332   c->u_mode.ccm.encryptlen -= inbuflen;
 333   burn = do_cbc_mac (c, inbuf, inbuflen, 0);
 334   if (burn)
 335     _gcry_burn_stack (burn + sizeof(void *) * 5);
 336
 337   return _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
 338 }
 339
 340
 341 gcry_err_code_t
 342 _gcry_cipher_ccm_decrypt (gcry_cipher_hd_t c, unsigned char *outbuf,
 343                           size_t outbuflen, const unsigned char *inbuf,
 344                           size_t inbuflen)
 345 {
 346   gcry_err_code_t err;
 347   unsigned int burn;
 348
 349   if (outbuflen < inbuflen)
 350     return GPG_ERR_BUFFER_TOO_SHORT;
 351   if (!c->u_mode.ccm.nonce || c->marks.tag || !c->u_mode.ccm.lengths ||
 352       c->u_mode.ccm.aadlen > 0)
 353     return GPG_ERR_INV_STATE;
 354   if (inbuflen > c->u_mode.ccm.encryptlen)
 355     return GPG_ERR_INV_LENGTH;
 356
 357   err = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
 358   if (err)
 359     return err;
 360
 361   c->u_mode.ccm.encryptlen -= inbuflen;
 362   burn = do_cbc_mac (c, outbuf, inbuflen, 0);
 363   if (burn)
 364     _gcry_burn_stack (burn + sizeof(void *) * 5);
 365
 366   return err;
 367 }