crypto/modes/gcm128.c

   1 /* ====================================================================
   2  * Copyright (c) 2010 The OpenSSL Project.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  *
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in
  13  *    the documentation and/or other materials provided with the
  14  *    distribution.
  15  *
  16  * 3. All advertising materials mentioning features or use of this
  17  *    software must display the following acknowledgment:
  18  *    "This product includes software developed by the OpenSSL Project
  19  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  20  *
  21  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  22  *    endorse or promote products derived from this software without
  23  *    prior written permission. For written permission, please contact
  24  *    openssl-core@openssl.org.
  25  *
  26  * 5. Products derived from this software may not be called "OpenSSL"
  27  *    nor may "OpenSSL" appear in their names without prior written
  28  *    permission of the OpenSSL Project.
  29  *
  30  * 6. Redistributions of any form whatsoever must retain the following
  31  *    acknowledgment:
  32  *    "This product includes software developed by the OpenSSL Project
  33  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  34  *
  35  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  36  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  37  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  38  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  39  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  41  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  42  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  43  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  44  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  45  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  46  * OF THE POSSIBILITY OF SUCH DAMAGE.
  47  * ====================================================================
  48  */
  49
  50 #include <openssl/crypto.h>
  51 #include "modes_lcl.h"
  52 #include <string.h>
  53
  54 #ifndef MODES_DEBUG
  55 # ifndef NDEBUG
  56 #  define NDEBUG
  57 # endif
  58 #endif
  59 #include <assert.h>
  60
  61 #if defined(BSWAP4) && defined(STRICT_ALIGNMENT)
  62 /* redefine, because alignment is ensured */
  63 # undef  GETU32
  64 # define GETU32(p)       BSWAP4(*(const u32 *)(p))
  65 # undef  PUTU32
  66 # define PUTU32(p,v)     *(u32 *)(p) = BSWAP4(v)
  67 #endif
  68
  69 #define PACK(s)         ((size_t)(s)<<(sizeof(size_t)*8-16))
  70 #define REDUCE1BIT(V)   do { \
  71         if (sizeof(size_t)==8) { \
  72                 u64 T = U64(0xe100000000000000) & (0-(V.lo&1)); \
  73                 V.lo  = (V.hi<<63)|(V.lo>>1); \
  74                 V.hi  = (V.hi>>1 )^T; \
  75         } \
  76         else { \
  77                 u32 T = 0xe1000000U & (0-(u32)(V.lo&1)); \
  78                 V.lo  = (V.hi<<63)|(V.lo>>1); \
  79                 V.hi  = (V.hi>>1 )^((u64)T<<32); \
  80         } \
  81 } while(0)
  82
  83 /*-
  84  * Even though permitted values for TABLE_BITS are 8, 4 and 1, it should
  85  * never be set to 8. 8 is effectively reserved for testing purposes.
  86  * TABLE_BITS>1 are lookup-table-driven implementations referred to as
  87  * "Shoup's" in GCM specification. In other words OpenSSL does not cover
  88  * whole spectrum of possible table driven implementations. Why? In
  89  * non-"Shoup's" case memory access pattern is segmented in such manner,
  90  * that it's trivial to see that cache timing information can reveal
  91  * fair portion of intermediate hash value. Given that ciphertext is
  92  * always available to attacker, it's possible for him to attempt to
  93  * deduce secret parameter H and if successful, tamper with messages
  94  * [which is nothing but trivial in CTR mode]. In "Shoup's" case it's
  95  * not as trivial, but there is no reason to believe that it's resistant
  96  * to cache-timing attack. And the thing about "8-bit" implementation is
  97  * that it consumes 16 (sixteen) times more memory, 4KB per individual
  98  * key + 1KB shared. Well, on pros side it should be twice as fast as
  99  * "4-bit" version. And for gcc-generated x86[_64] code, "8-bit" version
 100  * was observed to run ~75% faster, closer to 100% for commercial
 101  * compilers... Yet "4-bit" procedure is preferred, because it's
 102  * believed to provide better security-performance balance and adequate
 103  * all-round performance. "All-round" refers to things like:
 104  *
 105  * - shorter setup time effectively improves overall timing for
 106  *   handling short messages;
 107  * - larger table allocation can become unbearable because of VM
 108  *   subsystem penalties (for example on Windows large enough free
 109  *   results in VM working set trimming, meaning that consequent
 110  *   malloc would immediately incur working set expansion);
 111  * - larger table has larger cache footprint, which can affect
 112  *   performance of other code paths (not necessarily even from same
 113  *   thread in Hyper-Threading world);
 114  *
 115  * Value of 1 is not appropriate for performance reasons.
 116  */
 117 #if     TABLE_BITS==8
 118
 119 static void gcm_init_8bit(u128 Htable[256], u64 H[2])
 120 {
 121     int i, j;
 122     u128 V;
 123
 124     Htable[0].hi = 0;
 125     Htable[0].lo = 0;
 126     V.hi = H[0];
 127     V.lo = H[1];
 128
 129     for (Htable[128] = V, i = 64; i > 0; i >>= 1) {
 130         REDUCE1BIT(V);
 131         Htable[i] = V;
 132     }
 133
 134     for (i = 2; i < 256; i <<= 1) {
 135         u128 *Hi = Htable + i, H0 = *Hi;
 136         for (j = 1; j < i; ++j) {
 137             Hi[j].hi = H0.hi ^ Htable[j].hi;
 138             Hi[j].lo = H0.lo ^ Htable[j].lo;
 139         }
 140     }
 141 }
 142
 143 static void gcm_gmult_8bit(u64 Xi[2], const u128 Htable[256])
 144 {
 145     u128 Z = { 0, 0 };
 146     const u8 *xi = (const u8 *)Xi + 15;
 147     size_t rem, n = *xi;
 148     const union {
 149         long one;
 150         char little;
 151     } is_endian = { 1 };
 152     static const size_t rem_8bit[256] = {
 153         PACK(0x0000), PACK(0x01C2), PACK(0x0384), PACK(0x0246),
 154         PACK(0x0708), PACK(0x06CA), PACK(0x048C), PACK(0x054E),
 155         PACK(0x0E10), PACK(0x0FD2), PACK(0x0D94), PACK(0x0C56),
 156         PACK(0x0918), PACK(0x08DA), PACK(0x0A9C), PACK(0x0B5E),
 157         PACK(0x1C20), PACK(0x1DE2), PACK(0x1FA4), PACK(0x1E66),
 158         PACK(0x1B28), PACK(0x1AEA), PACK(0x18AC), PACK(0x196E),
 159         PACK(0x1230), PACK(0x13F2), PACK(0x11B4), PACK(0x1076),
 160         PACK(0x1538), PACK(0x14FA), PACK(0x16BC), PACK(0x177E),
 161         PACK(0x3840), PACK(0x3982), PACK(0x3BC4), PACK(0x3A06),
 162         PACK(0x3F48), PACK(0x3E8A), PACK(0x3CCC), PACK(0x3D0E),
 163         PACK(0x3650), PACK(0x3792), PACK(0x35D4), PACK(0x3416),
 164         PACK(0x3158), PACK(0x309A), PACK(0x32DC), PACK(0x331E),
 165         PACK(0x2460), PACK(0x25A2), PACK(0x27E4), PACK(0x2626),
 166         PACK(0x2368), PACK(0x22AA), PACK(0x20EC), PACK(0x212E),
 167         PACK(0x2A70), PACK(0x2BB2), PACK(0x29F4), PACK(0x2836),
 168         PACK(0x2D78), PACK(0x2CBA), PACK(0x2EFC), PACK(0x2F3E),
 169         PACK(0x7080), PACK(0x7142), PACK(0x7304), PACK(0x72C6),
 170         PACK(0x7788), PACK(0x764A), PACK(0x740C), PACK(0x75CE),
 171         PACK(0x7E90), PACK(0x7F52), PACK(0x7D14), PACK(0x7CD6),
 172         PACK(0x7998), PACK(0x785A), PACK(0x7A1C), PACK(0x7BDE),
 173         PACK(0x6CA0), PACK(0x6D62), PACK(0x6F24), PACK(0x6EE6),
 174         PACK(0x6BA8), PACK(0x6A6A), PACK(0x682C), PACK(0x69EE),
 175         PACK(0x62B0), PACK(0x6372), PACK(0x6134), PACK(0x60F6),
 176         PACK(0x65B8), PACK(0x647A), PACK(0x663C), PACK(0x67FE),
 177         PACK(0x48C0), PACK(0x4902), PACK(0x4B44), PACK(0x4A86),
 178         PACK(0x4FC8), PACK(0x4E0A), PACK(0x4C4C), PACK(0x4D8E),
 179         PACK(0x46D0), PACK(0x4712), PACK(0x4554), PACK(0x4496),
 180         PACK(0x41D8), PACK(0x401A), PACK(0x425C), PACK(0x439E),
 181         PACK(0x54E0), PACK(0x5522), PACK(0x5764), PACK(0x56A6),
 182         PACK(0x53E8), PACK(0x522A), PACK(0x506C), PACK(0x51AE),
 183         PACK(0x5AF0), PACK(0x5B32), PACK(0x5974), PACK(0x58B6),
 184         PACK(0x5DF8), PACK(0x5C3A), PACK(0x5E7C), PACK(0x5FBE),
 185         PACK(0xE100), PACK(0xE0C2), PACK(0xE284), PACK(0xE346),
 186         PACK(0xE608), PACK(0xE7CA), PACK(0xE58C), PACK(0xE44E),
 187         PACK(0xEF10), PACK(0xEED2), PACK(0xEC94), PACK(0xED56),
 188         PACK(0xE818), PACK(0xE9DA), PACK(0xEB9C), PACK(0xEA5E),
 189         PACK(0xFD20), PACK(0xFCE2), PACK(0xFEA4), PACK(0xFF66),
 190         PACK(0xFA28), PACK(0xFBEA), PACK(0xF9AC), PACK(0xF86E),
 191         PACK(0xF330), PACK(0xF2F2), PACK(0xF0B4), PACK(0xF176),
 192         PACK(0xF438), PACK(0xF5FA), PACK(0xF7BC), PACK(0xF67E),
 193         PACK(0xD940), PACK(0xD882), PACK(0xDAC4), PACK(0xDB06),
 194         PACK(0xDE48), PACK(0xDF8A), PACK(0xDDCC), PACK(0xDC0E),
 195         PACK(0xD750), PACK(0xD692), PACK(0xD4D4), PACK(0xD516),
 196         PACK(0xD058), PACK(0xD19A), PACK(0xD3DC), PACK(0xD21E),
 197         PACK(0xC560), PACK(0xC4A2), PACK(0xC6E4), PACK(0xC726),
 198         PACK(0xC268), PACK(0xC3AA), PACK(0xC1EC), PACK(0xC02E),
 199         PACK(0xCB70), PACK(0xCAB2), PACK(0xC8F4), PACK(0xC936),
 200         PACK(0xCC78), PACK(0xCDBA), PACK(0xCFFC), PACK(0xCE3E),
 201         PACK(0x9180), PACK(0x9042), PACK(0x9204), PACK(0x93C6),
 202         PACK(0x9688), PACK(0x974A), PACK(0x950C), PACK(0x94CE),
 203         PACK(0x9F90), PACK(0x9E52), PACK(0x9C14), PACK(0x9DD6),
 204         PACK(0x9898), PACK(0x995A), PACK(0x9B1C), PACK(0x9ADE),
 205         PACK(0x8DA0), PACK(0x8C62), PACK(0x8E24), PACK(0x8FE6),
 206         PACK(0x8AA8), PACK(0x8B6A), PACK(0x892C), PACK(0x88EE),
 207         PACK(0x83B0), PACK(0x8272), PACK(0x8034), PACK(0x81F6),
 208         PACK(0x84B8), PACK(0x857A), PACK(0x873C), PACK(0x86FE),
 209         PACK(0xA9C0), PACK(0xA802), PACK(0xAA44), PACK(0xAB86),
 210         PACK(0xAEC8), PACK(0xAF0A), PACK(0xAD4C), PACK(0xAC8E),
 211         PACK(0xA7D0), PACK(0xA612), PACK(0xA454), PACK(0xA596),
 212         PACK(0xA0D8), PACK(0xA11A), PACK(0xA35C), PACK(0xA29E),
 213         PACK(0xB5E0), PACK(0xB422), PACK(0xB664), PACK(0xB7A6),
 214         PACK(0xB2E8), PACK(0xB32A), PACK(0xB16C), PACK(0xB0AE),
 215         PACK(0xBBF0), PACK(0xBA32), PACK(0xB874), PACK(0xB9B6),
 216         PACK(0xBCF8), PACK(0xBD3A), PACK(0xBF7C), PACK(0xBEBE)
 217     };
 218
 219     while (1) {
 220         Z.hi ^= Htable[n].hi;
 221         Z.lo ^= Htable[n].lo;
 222
 223         if ((u8 *)Xi == xi)
 224             break;
 225
 226         n = *(--xi);
 227
 228         rem = (size_t)Z.lo & 0xff;
 229         Z.lo = (Z.hi << 56) | (Z.lo >> 8);
 230         Z.hi = (Z.hi >> 8);
 231         if (sizeof(size_t) == 8)
 232             Z.hi ^= rem_8bit[rem];
 233         else
 234             Z.hi ^= (u64)rem_8bit[rem] << 32;
 235     }
 236
 237     if (is_endian.little) {
 238 # ifdef BSWAP8
 239         Xi[0] = BSWAP8(Z.hi);
 240         Xi[1] = BSWAP8(Z.lo);
 241 # else
 242         u8 *p = (u8 *)Xi;
 243         u32 v;
 244         v = (u32)(Z.hi >> 32);
 245         PUTU32(p, v);
 246         v = (u32)(Z.hi);
 247         PUTU32(p + 4, v);
 248         v = (u32)(Z.lo >> 32);
 249         PUTU32(p + 8, v);
 250         v = (u32)(Z.lo);
 251         PUTU32(p + 12, v);
 252 # endif
 253     } else {
 254         Xi[0] = Z.hi;
 255         Xi[1] = Z.lo;
 256     }
 257 }
 258
 259 # define GCM_MUL(ctx,Xi)   gcm_gmult_8bit(ctx->Xi.u,ctx->Htable)
 260
 261 #elif   TABLE_BITS==4
 262
 263 static void gcm_init_4bit(u128 Htable[16], u64 H[2])
 264 {
 265     u128 V;
 266 # if defined(OPENSSL_SMALL_FOOTPRINT)
 267     int i;
 268 # endif
 269
 270     Htable[0].hi = 0;
 271     Htable[0].lo = 0;
 272     V.hi = H[0];
 273     V.lo = H[1];
 274
 275 # if defined(OPENSSL_SMALL_FOOTPRINT)
 276     for (Htable[8] = V, i = 4; i > 0; i >>= 1) {
 277         REDUCE1BIT(V);
 278         Htable[i] = V;
 279     }
 280
 281     for (i = 2; i < 16; i <<= 1) {
 282         u128 *Hi = Htable + i;
 283         int j;
 284         for (V = *Hi, j = 1; j < i; ++j) {
 285             Hi[j].hi = V.hi ^ Htable[j].hi;
 286             Hi[j].lo = V.lo ^ Htable[j].lo;
 287         }
 288     }
 289 # else
 290     Htable[8] = V;
 291     REDUCE1BIT(V);
 292     Htable[4] = V;
 293     REDUCE1BIT(V);
 294     Htable[2] = V;
 295     REDUCE1BIT(V);
 296     Htable[1] = V;
 297     Htable[3].hi = V.hi ^ Htable[2].hi, Htable[3].lo = V.lo ^ Htable[2].lo;
 298     V = Htable[4];
 299     Htable[5].hi = V.hi ^ Htable[1].hi, Htable[5].lo = V.lo ^ Htable[1].lo;
 300     Htable[6].hi = V.hi ^ Htable[2].hi, Htable[6].lo = V.lo ^ Htable[2].lo;
 301     Htable[7].hi = V.hi ^ Htable[3].hi, Htable[7].lo = V.lo ^ Htable[3].lo;
 302     V = Htable[8];
 303     Htable[9].hi = V.hi ^ Htable[1].hi, Htable[9].lo = V.lo ^ Htable[1].lo;
 304     Htable[10].hi = V.hi ^ Htable[2].hi, Htable[10].lo = V.lo ^ Htable[2].lo;
 305     Htable[11].hi = V.hi ^ Htable[3].hi, Htable[11].lo = V.lo ^ Htable[3].lo;
 306     Htable[12].hi = V.hi ^ Htable[4].hi, Htable[12].lo = V.lo ^ Htable[4].lo;
 307     Htable[13].hi = V.hi ^ Htable[5].hi, Htable[13].lo = V.lo ^ Htable[5].lo;
 308     Htable[14].hi = V.hi ^ Htable[6].hi, Htable[14].lo = V.lo ^ Htable[6].lo;
 309     Htable[15].hi = V.hi ^ Htable[7].hi, Htable[15].lo = V.lo ^ Htable[7].lo;
 310 # endif
 311 # if defined(GHASH_ASM) && (defined(__arm__) || defined(__arm))
 312     /*
 313      * ARM assembler expects specific dword order in Htable.
 314      */
 315     {
 316         int j;
 317         const union {
 318             long one;
 319             char little;
 320         } is_endian = { 1 };
 321
 322         if (is_endian.little)
 323             for (j = 0; j < 16; ++j) {
 324                 V = Htable[j];
 325                 Htable[j].hi = V.lo;
 326                 Htable[j].lo = V.hi;
 327         } else
 328             for (j = 0; j < 16; ++j) {
 329                 V = Htable[j];
 330                 Htable[j].hi = V.lo << 32 | V.lo >> 32;
 331                 Htable[j].lo = V.hi << 32 | V.hi >> 32;
 332             }
 333     }
 334 # endif
 335 }
 336
 337 # ifndef GHASH_ASM
 338 static const size_t rem_4bit[16] = {
 339     PACK(0x0000), PACK(0x1C20), PACK(0x3840), PACK(0x2460),
 340     PACK(0x7080), PACK(0x6CA0), PACK(0x48C0), PACK(0x54E0),
 341     PACK(0xE100), PACK(0xFD20), PACK(0xD940), PACK(0xC560),
 342     PACK(0x9180), PACK(0x8DA0), PACK(0xA9C0), PACK(0xB5E0)
 343 };
 344
 345 static void gcm_gmult_4bit(u64 Xi[2], const u128 Htable[16])
 346 {
 347     u128 Z;
 348     int cnt = 15;
 349     size_t rem, nlo, nhi;
 350     const union {
 351         long one;
 352         char little;
 353     } is_endian = { 1 };
 354
 355     nlo = ((const u8 *)Xi)[15];
 356     nhi = nlo >> 4;
 357     nlo &= 0xf;
 358
 359     Z.hi = Htable[nlo].hi;
 360     Z.lo = Htable[nlo].lo;
 361
 362     while (1) {
 363         rem = (size_t)Z.lo & 0xf;
 364         Z.lo = (Z.hi << 60) | (Z.lo >> 4);
 365         Z.hi = (Z.hi >> 4);
 366         if (sizeof(size_t) == 8)
 367             Z.hi ^= rem_4bit[rem];
 368         else
 369             Z.hi ^= (u64)rem_4bit[rem] << 32;
 370
 371         Z.hi ^= Htable[nhi].hi;
 372         Z.lo ^= Htable[nhi].lo;
 373
 374         if (--cnt < 0)
 375             break;
 376
 377         nlo = ((const u8 *)Xi)[cnt];
 378         nhi = nlo >> 4;
 379         nlo &= 0xf;
 380
 381         rem = (size_t)Z.lo & 0xf;
 382         Z.lo = (Z.hi << 60) | (Z.lo >> 4);
 383         Z.hi = (Z.hi >> 4);
 384         if (sizeof(size_t) == 8)
 385             Z.hi ^= rem_4bit[rem];
 386         else
 387             Z.hi ^= (u64)rem_4bit[rem] << 32;
 388
 389         Z.hi ^= Htable[nlo].hi;
 390         Z.lo ^= Htable[nlo].lo;
 391     }
 392
 393     if (is_endian.little) {
 394 #  ifdef BSWAP8
 395         Xi[0] = BSWAP8(Z.hi);
 396         Xi[1] = BSWAP8(Z.lo);
 397 #  else
 398         u8 *p = (u8 *)Xi;
 399         u32 v;
 400         v = (u32)(Z.hi >> 32);
 401         PUTU32(p, v);
 402         v = (u32)(Z.hi);
 403         PUTU32(p + 4, v);
 404         v = (u32)(Z.lo >> 32);
 405         PUTU32(p + 8, v);
 406         v = (u32)(Z.lo);
 407         PUTU32(p + 12, v);
 408 #  endif
 409     } else {
 410         Xi[0] = Z.hi;
 411         Xi[1] = Z.lo;
 412     }
 413 }
 414
 415 #  if !defined(OPENSSL_SMALL_FOOTPRINT)
 416 /*
 417  * Streamed gcm_mult_4bit, see CRYPTO_gcm128_[en|de]crypt for
 418  * details... Compiler-generated code doesn't seem to give any
 419  * performance improvement, at least not on x86[_64]. It's here
 420  * mostly as reference and a placeholder for possible future
 421  * non-trivial optimization[s]...
 422  */
 423 static void gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16],
 424                            const u8 *inp, size_t len)
 425 {
 426     u128 Z;
 427     int cnt;
 428     size_t rem, nlo, nhi;
 429     const union {
 430         long one;
 431         char little;
 432     } is_endian = { 1 };
 433
 434 #   if 1
 435     do {
 436         cnt = 15;
 437         nlo = ((const u8 *)Xi)[15];
 438         nlo ^= inp[15];
 439         nhi = nlo >> 4;
 440         nlo &= 0xf;
 441
 442         Z.hi = Htable[nlo].hi;
 443         Z.lo = Htable[nlo].lo;
 444
 445         while (1) {
 446             rem = (size_t)Z.lo & 0xf;
 447             Z.lo = (Z.hi << 60) | (Z.lo >> 4);
 448             Z.hi = (Z.hi >> 4);
 449             if (sizeof(size_t) == 8)
 450                 Z.hi ^= rem_4bit[rem];
 451             else
 452                 Z.hi ^= (u64)rem_4bit[rem] << 32;
 453
 454             Z.hi ^= Htable[nhi].hi;
 455             Z.lo ^= Htable[nhi].lo;
 456
 457             if (--cnt < 0)
 458                 break;
 459
 460             nlo = ((const u8 *)Xi)[cnt];
 461             nlo ^= inp[cnt];
 462             nhi = nlo >> 4;
 463             nlo &= 0xf;
 464
 465             rem = (size_t)Z.lo & 0xf;
 466             Z.lo = (Z.hi << 60) | (Z.lo >> 4);
 467             Z.hi = (Z.hi >> 4);
 468             if (sizeof(size_t) == 8)
 469                 Z.hi ^= rem_4bit[rem];
 470             else
 471                 Z.hi ^= (u64)rem_4bit[rem] << 32;
 472
 473             Z.hi ^= Htable[nlo].hi;
 474             Z.lo ^= Htable[nlo].lo;
 475         }
 476 #   else
 477     /*
 478      * Extra 256+16 bytes per-key plus 512 bytes shared tables
 479      * [should] give ~50% improvement... One could have PACK()-ed
 480      * the rem_8bit even here, but the priority is to minimize
 481      * cache footprint...
 482      */
 483     u128 Hshr4[16];             /* Htable shifted right by 4 bits */
 484     u8 Hshl4[16];               /* Htable shifted left by 4 bits */
 485     static const unsigned short rem_8bit[256] = {
 486         0x0000, 0x01C2, 0x0384, 0x0246, 0x0708, 0x06CA, 0x048C, 0x054E,
 487         0x0E10, 0x0FD2, 0x0D94, 0x0C56, 0x0918, 0x08DA, 0x0A9C, 0x0B5E,
 488         0x1C20, 0x1DE2, 0x1FA4, 0x1E66, 0x1B28, 0x1AEA, 0x18AC, 0x196E,
 489         0x1230, 0x13F2, 0x11B4, 0x1076, 0x1538, 0x14FA, 0x16BC, 0x177E,
 490         0x3840, 0x3982, 0x3BC4, 0x3A06, 0x3F48, 0x3E8A, 0x3CCC, 0x3D0E,
 491         0x3650, 0x3792, 0x35D4, 0x3416, 0x3158, 0x309A, 0x32DC, 0x331E,
 492         0x2460, 0x25A2, 0x27E4, 0x2626, 0x2368, 0x22AA, 0x20EC, 0x212E,
 493         0x2A70, 0x2BB2, 0x29F4, 0x2836, 0x2D78, 0x2CBA, 0x2EFC, 0x2F3E,
 494         0x7080, 0x7142, 0x7304, 0x72C6, 0x7788, 0x764A, 0x740C, 0x75CE,
 495         0x7E90, 0x7F52, 0x7D14, 0x7CD6, 0x7998, 0x785A, 0x7A1C, 0x7BDE,
 496         0x6CA0, 0x6D62, 0x6F24, 0x6EE6, 0x6BA8, 0x6A6A, 0x682C, 0x69EE,
 497         0x62B0, 0x6372, 0x6134, 0x60F6, 0x65B8, 0x647A, 0x663C, 0x67FE,
 498         0x48C0, 0x4902, 0x4B44, 0x4A86, 0x4FC8, 0x4E0A, 0x4C4C, 0x4D8E,
 499         0x46D0, 0x4712, 0x4554, 0x4496, 0x41D8, 0x401A, 0x425C, 0x439E,
 500         0x54E0, 0x5522, 0x5764, 0x56A6, 0x53E8, 0x522A, 0x506C, 0x51AE,
 501         0x5AF0, 0x5B32, 0x5974, 0x58B6, 0x5DF8, 0x5C3A, 0x5E7C, 0x5FBE,
 502         0xE100, 0xE0C2, 0xE284, 0xE346, 0xE608, 0xE7CA, 0xE58C, 0xE44E,
 503         0xEF10, 0xEED2, 0xEC94, 0xED56, 0xE818, 0xE9DA, 0xEB9C, 0xEA5E,
 504         0xFD20, 0xFCE2, 0xFEA4, 0xFF66, 0xFA28, 0xFBEA, 0xF9AC, 0xF86E,
 505         0xF330, 0xF2F2, 0xF0B4, 0xF176, 0xF438, 0xF5FA, 0xF7BC, 0xF67E,
 506         0xD940, 0xD882, 0xDAC4, 0xDB06, 0xDE48, 0xDF8A, 0xDDCC, 0xDC0E,
 507         0xD750, 0xD692, 0xD4D4, 0xD516, 0xD058, 0xD19A, 0xD3DC, 0xD21E,
 508         0xC560, 0xC4A2, 0xC6E4, 0xC726, 0xC268, 0xC3AA, 0xC1EC, 0xC02E,
 509         0xCB70, 0xCAB2, 0xC8F4, 0xC936, 0xCC78, 0xCDBA, 0xCFFC, 0xCE3E,
 510         0x9180, 0x9042, 0x9204, 0x93C6, 0x9688, 0x974A, 0x950C, 0x94CE,
 511         0x9F90, 0x9E52, 0x9C14, 0x9DD6, 0x9898, 0x995A, 0x9B1C, 0x9ADE,
 512         0x8DA0, 0x8C62, 0x8E24, 0x8FE6, 0x8AA8, 0x8B6A, 0x892C, 0x88EE,
 513         0x83B0, 0x8272, 0x8034, 0x81F6, 0x84B8, 0x857A, 0x873C, 0x86FE,
 514         0xA9C0, 0xA802, 0xAA44, 0xAB86, 0xAEC8, 0xAF0A, 0xAD4C, 0xAC8E,
 515         0xA7D0, 0xA612, 0xA454, 0xA596, 0xA0D8, 0xA11A, 0xA35C, 0xA29E,
 516         0xB5E0, 0xB422, 0xB664, 0xB7A6, 0xB2E8, 0xB32A, 0xB16C, 0xB0AE,
 517         0xBBF0, 0xBA32, 0xB874, 0xB9B6, 0xBCF8, 0xBD3A, 0xBF7C, 0xBEBE
 518     };
 519     /*
 520      * This pre-processing phase slows down procedure by approximately
 521      * same time as it makes each loop spin faster. In other words
 522      * single block performance is approximately same as straightforward
 523      * "4-bit" implementation, and then it goes only faster...
 524      */
 525     for (cnt = 0; cnt < 16; ++cnt) {
 526         Z.hi = Htable[cnt].hi;
 527         Z.lo = Htable[cnt].lo;
 528         Hshr4[cnt].lo = (Z.hi << 60) | (Z.lo >> 4);
 529         Hshr4[cnt].hi = (Z.hi >> 4);
 530         Hshl4[cnt] = (u8)(Z.lo << 4);
 531     }
 532
 533     do {
 534         for (Z.lo = 0, Z.hi = 0, cnt = 15; cnt; --cnt) {
 535             nlo = ((const u8 *)Xi)[cnt];
 536             nlo ^= inp[cnt];
 537             nhi = nlo >> 4;
 538             nlo &= 0xf;
 539
 540             Z.hi ^= Htable[nlo].hi;
 541             Z.lo ^= Htable[nlo].lo;
 542
 543             rem = (size_t)Z.lo & 0xff;
 544
 545             Z.lo = (Z.hi << 56) | (Z.lo >> 8);
 546             Z.hi = (Z.hi >> 8);
 547
 548             Z.hi ^= Hshr4[nhi].hi;
 549             Z.lo ^= Hshr4[nhi].lo;
 550             Z.hi ^= (u64)rem_8bit[rem ^ Hshl4[nhi]] << 48;
 551         }
 552
 553         nlo = ((const u8 *)Xi)[0];
 554         nlo ^= inp[0];
 555         nhi = nlo >> 4;
 556         nlo &= 0xf;
 557
 558         Z.hi ^= Htable[nlo].hi;
 559         Z.lo ^= Htable[nlo].lo;
 560
 561         rem = (size_t)Z.lo & 0xf;
 562
 563         Z.lo = (Z.hi << 60) | (Z.lo >> 4);
 564         Z.hi = (Z.hi >> 4);
 565
 566         Z.hi ^= Htable[nhi].hi;
 567         Z.lo ^= Htable[nhi].lo;
 568         Z.hi ^= ((u64)rem_8bit[rem << 4]) << 48;
 569 #   endif
 570
 571         if (is_endian.little) {
 572 #   ifdef BSWAP8
 573             Xi[0] = BSWAP8(Z.hi);
 574             Xi[1] = BSWAP8(Z.lo);
 575 #   else
 576             u8 *p = (u8 *)Xi;
 577             u32 v;
 578             v = (u32)(Z.hi >> 32);
 579             PUTU32(p, v);
 580             v = (u32)(Z.hi);
 581             PUTU32(p + 4, v);
 582             v = (u32)(Z.lo >> 32);
 583             PUTU32(p + 8, v);
 584             v = (u32)(Z.lo);
 585             PUTU32(p + 12, v);
 586 #   endif
 587         } else {
 588             Xi[0] = Z.hi;
 589             Xi[1] = Z.lo;
 590         }
 591     } while (inp += 16, len -= 16);
 592 }
 593 #  endif
 594 # else
 595 void gcm_gmult_4bit(u64 Xi[2], const u128 Htable[16]);
 596 void gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 597                     size_t len);
 598 # endif
 599
 600 # define GCM_MUL(ctx,Xi)   gcm_gmult_4bit(ctx->Xi.u,ctx->Htable)
 601 # if defined(GHASH_ASM) || !defined(OPENSSL_SMALL_FOOTPRINT)
 602 #  define GHASH(ctx,in,len) gcm_ghash_4bit((ctx)->Xi.u,(ctx)->Htable,in,len)
 603 /*
 604  * GHASH_CHUNK is "stride parameter" missioned to mitigate cache trashing
 605  * effect. In other words idea is to hash data while it's still in L1 cache
 606  * after encryption pass...
 607  */
 608 #  define GHASH_CHUNK       (3*1024)
 609 # endif
 610
 611 #else                           /* TABLE_BITS */
 612
 613 static void gcm_gmult_1bit(u64 Xi[2], const u64 H[2])
 614 {
 615     u128 V, Z = { 0, 0 };
 616     long X;
 617     int i, j;
 618     const long *xi = (const long *)Xi;
 619     const union {
 620         long one;
 621         char little;
 622     } is_endian = { 1 };
 623
 624     V.hi = H[0];                /* H is in host byte order, no byte swapping */
 625     V.lo = H[1];
 626
 627     for (j = 0; j < 16 / sizeof(long); ++j) {
 628         if (is_endian.little) {
 629             if (sizeof(long) == 8) {
 630 # ifdef BSWAP8
 631                 X = (long)(BSWAP8(xi[j]));
 632 # else
 633                 const u8 *p = (const u8 *)(xi + j);
 634                 X = (long)((u64)GETU32(p) << 32 | GETU32(p + 4));
 635 # endif
 636             } else {
 637                 const u8 *p = (const u8 *)(xi + j);
 638                 X = (long)GETU32(p);
 639             }
 640         } else
 641             X = xi[j];
 642
 643         for (i = 0; i < 8 * sizeof(long); ++i, X <<= 1) {
 644             u64 M = (u64)(X >> (8 * sizeof(long) - 1));
 645             Z.hi ^= V.hi & M;
 646             Z.lo ^= V.lo & M;
 647
 648             REDUCE1BIT(V);
 649         }
 650     }
 651
 652     if (is_endian.little) {
 653 # ifdef BSWAP8
 654         Xi[0] = BSWAP8(Z.hi);
 655         Xi[1] = BSWAP8(Z.lo);
 656 # else
 657         u8 *p = (u8 *)Xi;
 658         u32 v;
 659         v = (u32)(Z.hi >> 32);
 660         PUTU32(p, v);
 661         v = (u32)(Z.hi);
 662         PUTU32(p + 4, v);
 663         v = (u32)(Z.lo >> 32);
 664         PUTU32(p + 8, v);
 665         v = (u32)(Z.lo);
 666         PUTU32(p + 12, v);
 667 # endif
 668     } else {
 669         Xi[0] = Z.hi;
 670         Xi[1] = Z.lo;
 671     }
 672 }
 673
 674 # define GCM_MUL(ctx,Xi)   gcm_gmult_1bit(ctx->Xi.u,ctx->H.u)
 675
 676 #endif
 677
 678 #if     TABLE_BITS==4 && (defined(GHASH_ASM) || defined(OPENSSL_CPUID_OBJ))
 679 # if    !defined(I386_ONLY) && \
 680         (defined(__i386)        || defined(__i386__)    || \
 681          defined(__x86_64)      || defined(__x86_64__)  || \
 682          defined(_M_IX86)       || defined(_M_AMD64)    || defined(_M_X64))
 683 #  define GHASH_ASM_X86_OR_64
 684 #  define GCM_FUNCREF_4BIT
 685 extern unsigned int OPENSSL_ia32cap_P[2];
 686
 687 void gcm_init_clmul(u128 Htable[16], const u64 Xi[2]);
 688 void gcm_gmult_clmul(u64 Xi[2], const u128 Htable[16]);
 689 void gcm_ghash_clmul(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 690                      size_t len);
 691
 692 #  if defined(__i386) || defined(__i386__) || defined(_M_IX86)
 693 #   define gcm_init_avx   gcm_init_clmul
 694 #   define gcm_gmult_avx  gcm_gmult_clmul
 695 #   define gcm_ghash_avx  gcm_ghash_clmul
 696 #  else
 697 void gcm_init_avx(u128 Htable[16], const u64 Xi[2]);
 698 void gcm_gmult_avx(u64 Xi[2], const u128 Htable[16]);
 699 void gcm_ghash_avx(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 700                    size_t len);
 701 #  endif
 702
 703 #  if   defined(__i386) || defined(__i386__) || defined(_M_IX86)
 704 #   define GHASH_ASM_X86
 705 void gcm_gmult_4bit_mmx(u64 Xi[2], const u128 Htable[16]);
 706 void gcm_ghash_4bit_mmx(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 707                         size_t len);
 708
 709 void gcm_gmult_4bit_x86(u64 Xi[2], const u128 Htable[16]);
 710 void gcm_ghash_4bit_x86(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 711                         size_t len);
 712 #  endif
 713 # elif defined(__arm__) || defined(__arm) || defined(__aarch64__)
 714 #  include "arm_arch.h"
 715 #  if __ARM_MAX_ARCH__>=7
 716 #   define GHASH_ASM_ARM
 717 #   define GCM_FUNCREF_4BIT
 718 #   define PMULL_CAPABLE        (OPENSSL_armcap_P & ARMV8_PMULL)
 719 #   if defined(__arm__) || defined(__arm)
 720 #    define NEON_CAPABLE        (OPENSSL_armcap_P & ARMV7_NEON)
 721 #   endif
 722 void gcm_init_neon(u128 Htable[16], const u64 Xi[2]);
 723 void gcm_gmult_neon(u64 Xi[2], const u128 Htable[16]);
 724 void gcm_ghash_neon(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 725                     size_t len);
 726 void gcm_init_v8(u128 Htable[16], const u64 Xi[2]);
 727 void gcm_gmult_v8(u64 Xi[2], const u128 Htable[16]);
 728 void gcm_ghash_v8(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 729                   size_t len);
 730 #  endif
 731 # elif defined(__sparc__) || defined(__sparc)
 732 #  include "sparc_arch.h"
 733 #  define GHASH_ASM_SPARC
 734 #  define GCM_FUNCREF_4BIT
 735 extern unsigned int OPENSSL_sparcv9cap_P[];
 736 void gcm_init_vis3(u128 Htable[16], const u64 Xi[2]);
 737 void gcm_gmult_vis3(u64 Xi[2], const u128 Htable[16]);
 738 void gcm_ghash_vis3(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 739                     size_t len);
 740 # elif defined(OPENSSL_CPUID_OBJ) && (defined(__powerpc__) || defined(__ppc__) || defined(_ARCH_PPC))
 741 #  include "ppc_arch.h"
 742 #  define GHASH_ASM_PPC
 743 #  define GCM_FUNCREF_4BIT
 744 void gcm_init_p8(u128 Htable[16], const u64 Xi[2]);
 745 void gcm_gmult_p8(u64 Xi[2], const u128 Htable[16]);
 746 void gcm_ghash_p8(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 747                   size_t len);
 748 # endif
 749 #endif
 750
 751 #ifdef GCM_FUNCREF_4BIT
 752 # undef  GCM_MUL
 753 # define GCM_MUL(ctx,Xi)        (*gcm_gmult_p)(ctx->Xi.u,ctx->Htable)
 754 # ifdef GHASH
 755 #  undef  GHASH
 756 #  define GHASH(ctx,in,len)     (*gcm_ghash_p)(ctx->Xi.u,ctx->Htable,in,len)
 757 # endif
 758 #endif
 759
 760 void CRYPTO_gcm128_init(GCM128_CONTEXT *ctx, void *key, block128_f block)
 761 {
 762     const union {
 763         long one;
 764         char little;
 765     } is_endian = { 1 };
 766
 767     memset(ctx, 0, sizeof(*ctx));
 768     ctx->block = block;
 769     ctx->key = key;
 770
 771     (*block) (ctx->H.c, ctx->H.c, key);
 772
 773     if (is_endian.little) {
 774         /* H is stored in host byte order */
 775 #ifdef BSWAP8
 776         ctx->H.u[0] = BSWAP8(ctx->H.u[0]);
 777         ctx->H.u[1] = BSWAP8(ctx->H.u[1]);
 778 #else
 779         u8 *p = ctx->H.c;
 780         u64 hi, lo;
 781         hi = (u64)GETU32(p) << 32 | GETU32(p + 4);
 782         lo = (u64)GETU32(p + 8) << 32 | GETU32(p + 12);
 783         ctx->H.u[0] = hi;
 784         ctx->H.u[1] = lo;
 785 #endif
 786     }
 787 #if     TABLE_BITS==8
 788     gcm_init_8bit(ctx->Htable, ctx->H.u);
 789 #elif   TABLE_BITS==4
 790 # if    defined(GHASH)
 791 #  define CTX__GHASH(f) (ctx->ghash = (f))
 792 # else
 793 #  define CTX__GHASH(f) (ctx->ghash = NULL)
 794 # endif
 795 # if    defined(GHASH_ASM_X86_OR_64)
 796 #  if   !defined(GHASH_ASM_X86) || defined(OPENSSL_IA32_SSE2)
 797     if (OPENSSL_ia32cap_P[0] & (1 << 24) && /* check FXSR bit */
 798         OPENSSL_ia32cap_P[1] & (1 << 1)) { /* check PCLMULQDQ bit */
 799         if (((OPENSSL_ia32cap_P[1] >> 22) & 0x41) == 0x41) { /* AVX+MOVBE */
 800             gcm_init_avx(ctx->Htable, ctx->H.u);
 801             ctx->gmult = gcm_gmult_avx;
 802             CTX__GHASH(gcm_ghash_avx);
 803         } else {
 804             gcm_init_clmul(ctx->Htable, ctx->H.u);
 805             ctx->gmult = gcm_gmult_clmul;
 806             CTX__GHASH(gcm_ghash_clmul);
 807         }
 808         return;
 809     }
 810 #  endif
 811     gcm_init_4bit(ctx->Htable, ctx->H.u);
 812 #  if   defined(GHASH_ASM_X86)  /* x86 only */
 813 #   if  defined(OPENSSL_IA32_SSE2)
 814     if (OPENSSL_ia32cap_P[0] & (1 << 25)) { /* check SSE bit */
 815 #   else
 816     if (OPENSSL_ia32cap_P[0] & (1 << 23)) { /* check MMX bit */
 817 #   endif
 818         ctx->gmult = gcm_gmult_4bit_mmx;
 819         CTX__GHASH(gcm_ghash_4bit_mmx);
 820     } else {
 821         ctx->gmult = gcm_gmult_4bit_x86;
 822         CTX__GHASH(gcm_ghash_4bit_x86);
 823     }
 824 #  else
 825     ctx->gmult = gcm_gmult_4bit;
 826     CTX__GHASH(gcm_ghash_4bit);
 827 #  endif
 828 # elif  defined(GHASH_ASM_ARM)
 829 #  ifdef PMULL_CAPABLE
 830     if (PMULL_CAPABLE) {
 831         gcm_init_v8(ctx->Htable, ctx->H.u);
 832         ctx->gmult = gcm_gmult_v8;
 833         CTX__GHASH(gcm_ghash_v8);
 834     } else
 835 #  endif
 836 #  ifdef NEON_CAPABLE
 837     if (NEON_CAPABLE) {
 838         gcm_init_neon(ctx->Htable, ctx->H.u);
 839         ctx->gmult = gcm_gmult_neon;
 840         CTX__GHASH(gcm_ghash_neon);
 841     } else
 842 #  endif
 843     {
 844         gcm_init_4bit(ctx->Htable, ctx->H.u);
 845         ctx->gmult = gcm_gmult_4bit;
 846         CTX__GHASH(gcm_ghash_4bit);
 847     }
 848 # elif  defined(GHASH_ASM_SPARC)
 849     if (OPENSSL_sparcv9cap_P[0] & SPARCV9_VIS3) {
 850         gcm_init_vis3(ctx->Htable, ctx->H.u);
 851         ctx->gmult = gcm_gmult_vis3;
 852         CTX__GHASH(gcm_ghash_vis3);
 853     } else {
 854         gcm_init_4bit(ctx->Htable, ctx->H.u);
 855         ctx->gmult = gcm_gmult_4bit;
 856         CTX__GHASH(gcm_ghash_4bit);
 857     }
 858 # elif  defined(GHASH_ASM_PPC)
 859     if (OPENSSL_ppccap_P & PPC_CRYPTO207) {
 860         gcm_init_p8(ctx->Htable, ctx->H.u);
 861         ctx->gmult = gcm_gmult_p8;
 862         CTX__GHASH(gcm_ghash_p8);
 863     } else {
 864         gcm_init_4bit(ctx->Htable, ctx->H.u);
 865         ctx->gmult = gcm_gmult_4bit;
 866         CTX__GHASH(gcm_ghash_4bit);
 867     }
 868 # else
 869     gcm_init_4bit(ctx->Htable, ctx->H.u);
 870 # endif
 871 # undef CTX__GHASH
 872 #endif
 873 }
 874
 875 void CRYPTO_gcm128_setiv(GCM128_CONTEXT *ctx, const unsigned char *iv,
 876                          size_t len)
 877 {
 878     const union {
 879         long one;
 880         char little;
 881     } is_endian = { 1 };
 882     unsigned int ctr;
 883 #ifdef GCM_FUNCREF_4BIT
 884     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
 885 #endif
 886
 887     ctx->Yi.u[0] = 0;
 888     ctx->Yi.u[1] = 0;
 889     ctx->Xi.u[0] = 0;
 890     ctx->Xi.u[1] = 0;
 891     ctx->len.u[0] = 0;          /* AAD length */
 892     ctx->len.u[1] = 0;          /* message length */
 893     ctx->ares = 0;
 894     ctx->mres = 0;
 895
 896     if (len == 12) {
 897         memcpy(ctx->Yi.c, iv, 12);
 898         ctx->Yi.c[15] = 1;
 899         ctr = 1;
 900     } else {
 901         size_t i;
 902         u64 len0 = len;
 903
 904         while (len >= 16) {
 905             for (i = 0; i < 16; ++i)
 906                 ctx->Yi.c[i] ^= iv[i];
 907             GCM_MUL(ctx, Yi);
 908             iv += 16;
 909             len -= 16;
 910         }
 911         if (len) {
 912             for (i = 0; i < len; ++i)
 913                 ctx->Yi.c[i] ^= iv[i];
 914             GCM_MUL(ctx, Yi);
 915         }
 916         len0 <<= 3;
 917         if (is_endian.little) {
 918 #ifdef BSWAP8
 919             ctx->Yi.u[1] ^= BSWAP8(len0);
 920 #else
 921             ctx->Yi.c[8] ^= (u8)(len0 >> 56);
 922             ctx->Yi.c[9] ^= (u8)(len0 >> 48);
 923             ctx->Yi.c[10] ^= (u8)(len0 >> 40);
 924             ctx->Yi.c[11] ^= (u8)(len0 >> 32);
 925             ctx->Yi.c[12] ^= (u8)(len0 >> 24);
 926             ctx->Yi.c[13] ^= (u8)(len0 >> 16);
 927             ctx->Yi.c[14] ^= (u8)(len0 >> 8);
 928             ctx->Yi.c[15] ^= (u8)(len0);
 929 #endif
 930         } else
 931             ctx->Yi.u[1] ^= len0;
 932
 933         GCM_MUL(ctx, Yi);
 934
 935         if (is_endian.little)
 936 #ifdef BSWAP4
 937             ctr = BSWAP4(ctx->Yi.d[3]);
 938 #else
 939             ctr = GETU32(ctx->Yi.c + 12);
 940 #endif
 941         else
 942             ctr = ctx->Yi.d[3];
 943     }
 944
 945     (*ctx->block) (ctx->Yi.c, ctx->EK0.c, ctx->key);
 946     ++ctr;
 947     if (is_endian.little)
 948 #ifdef BSWAP4
 949         ctx->Yi.d[3] = BSWAP4(ctr);
 950 #else
 951         PUTU32(ctx->Yi.c + 12, ctr);
 952 #endif
 953     else
 954         ctx->Yi.d[3] = ctr;
 955 }
 956
 957 int CRYPTO_gcm128_aad(GCM128_CONTEXT *ctx, const unsigned char *aad,
 958                       size_t len)
 959 {
 960     size_t i;
 961     unsigned int n;
 962     u64 alen = ctx->len.u[0];
 963 #ifdef GCM_FUNCREF_4BIT
 964     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
 965 # ifdef GHASH
 966     void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
 967                          const u8 *inp, size_t len) = ctx->ghash;
 968 # endif
 969 #endif
 970
 971     if (ctx->len.u[1])
 972         return -2;
 973
 974     alen += len;
 975     if (alen > (U64(1) << 61) || (sizeof(len) == 8 && alen < len))
 976         return -1;
 977     ctx->len.u[0] = alen;
 978
 979     n = ctx->ares;
 980     if (n) {
 981         while (n && len) {
 982             ctx->Xi.c[n] ^= *(aad++);
 983             --len;
 984             n = (n + 1) % 16;
 985         }
 986         if (n == 0)
 987             GCM_MUL(ctx, Xi);
 988         else {
 989             ctx->ares = n;
 990             return 0;
 991         }
 992     }
 993 #ifdef GHASH
 994     if ((i = (len & (size_t)-16))) {
 995         GHASH(ctx, aad, i);
 996         aad += i;
 997         len -= i;
 998     }
 999 #else
1000     while (len >= 16) {
1001         for (i = 0; i < 16; ++i)
1002             ctx->Xi.c[i] ^= aad[i];
1003         GCM_MUL(ctx, Xi);
1004         aad += 16;
1005         len -= 16;
1006     }
1007 #endif
1008     if (len) {
1009         n = (unsigned int)len;
1010         for (i = 0; i < len; ++i)
1011             ctx->Xi.c[i] ^= aad[i];
1012     }
1013
1014     ctx->ares = n;
1015     return 0;
1016 }
1017
1018 int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx,
1019                           const unsigned char *in, unsigned char *out,
1020                           size_t len)
1021 {
1022     const union {
1023         long one;
1024         char little;
1025     } is_endian = { 1 };
1026     unsigned int n, ctr;
1027     size_t i;
1028     u64 mlen = ctx->len.u[1];
1029     block128_f block = ctx->block;
1030     void *key = ctx->key;
1031 #ifdef GCM_FUNCREF_4BIT
1032     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
1033 # if defined(GHASH) && !defined(OPENSSL_SMALL_FOOTPRINT)
1034     void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
1035                          const u8 *inp, size_t len) = ctx->ghash;
1036 # endif
1037 #endif
1038
1039     mlen += len;
1040     if (mlen > ((U64(1) << 36) - 32) || (sizeof(len) == 8 && mlen < len))
1041         return -1;
1042     ctx->len.u[1] = mlen;
1043
1044     if (ctx->ares) {
1045         /* First call to encrypt finalizes GHASH(AAD) */
1046         GCM_MUL(ctx, Xi);
1047         ctx->ares = 0;
1048     }
1049
1050     if (is_endian.little)
1051 #ifdef BSWAP4
1052         ctr = BSWAP4(ctx->Yi.d[3]);
1053 #else
1054         ctr = GETU32(ctx->Yi.c + 12);
1055 #endif
1056     else
1057         ctr = ctx->Yi.d[3];
1058
1059     n = ctx->mres;
1060 #if !defined(OPENSSL_SMALL_FOOTPRINT)
1061     if (16 % sizeof(size_t) == 0) { /* always true actually */
1062         do {
1063             if (n) {
1064                 while (n && len) {
1065                     ctx->Xi.c[n] ^= *(out++) = *(in++) ^ ctx->EKi.c[n];
1066                     --len;
1067                     n = (n + 1) % 16;
1068                 }
1069                 if (n == 0)
1070                     GCM_MUL(ctx, Xi);
1071                 else {
1072                     ctx->mres = n;
1073                     return 0;
1074                 }
1075             }
1076 # if defined(STRICT_ALIGNMENT)
1077             if (((size_t)in | (size_t)out) % sizeof(size_t) != 0)
1078                 break;
1079 # endif
1080 # if defined(GHASH)
1081 #  if defined(GHASH_CHUNK)
1082             while (len >= GHASH_CHUNK) {
1083                 size_t j = GHASH_CHUNK;
1084
1085                 while (j) {
1086                     size_t *out_t = (size_t *)out;
1087                     const size_t *in_t = (const size_t *)in;
1088
1089                     (*block) (ctx->Yi.c, ctx->EKi.c, key);
1090                     ++ctr;
1091                     if (is_endian.little)
1092 #   ifdef BSWAP4
1093                         ctx->Yi.d[3] = BSWAP4(ctr);
1094 #   else
1095                         PUTU32(ctx->Yi.c + 12, ctr);
1096 #   endif
1097                     else
1098                         ctx->Yi.d[3] = ctr;
1099                     for (i = 0; i < 16 / sizeof(size_t); ++i)
1100                         out_t[i] = in_t[i] ^ ctx->EKi.t[i];
1101                     out += 16;
1102                     in += 16;
1103                     j -= 16;
1104                 }
1105                 GHASH(ctx, out - GHASH_CHUNK, GHASH_CHUNK);
1106                 len -= GHASH_CHUNK;
1107             }
1108 #  endif
1109             if ((i = (len & (size_t)-16))) {
1110                 size_t j = i;
1111
1112                 while (len >= 16) {
1113                     size_t *out_t = (size_t *)out;
1114                     const size_t *in_t = (const size_t *)in;
1115
1116                     (*block) (ctx->Yi.c, ctx->EKi.c, key);
1117                     ++ctr;
1118                     if (is_endian.little)
1119 #  ifdef BSWAP4
1120                         ctx->Yi.d[3] = BSWAP4(ctr);
1121 #  else
1122                         PUTU32(ctx->Yi.c + 12, ctr);
1123 #  endif
1124                     else
1125                         ctx->Yi.d[3] = ctr;
1126                     for (i = 0; i < 16 / sizeof(size_t); ++i)
1127                         out_t[i] = in_t[i] ^ ctx->EKi.t[i];
1128                     out += 16;
1129                     in += 16;
1130                     len -= 16;
1131                 }
1132                 GHASH(ctx, out - j, j);
1133             }
1134 # else
1135             while (len >= 16) {
1136                 size_t *out_t = (size_t *)out;
1137                 const size_t *in_t = (const size_t *)in;
1138
1139                 (*block) (ctx->Yi.c, ctx->EKi.c, key);
1140                 ++ctr;
1141                 if (is_endian.little)
1142 #  ifdef BSWAP4
1143                     ctx->Yi.d[3] = BSWAP4(ctr);
1144 #  else
1145                     PUTU32(ctx->Yi.c + 12, ctr);
1146 #  endif
1147                 else
1148                     ctx->Yi.d[3] = ctr;
1149                 for (i = 0; i < 16 / sizeof(size_t); ++i)
1150                     ctx->Xi.t[i] ^= out_t[i] = in_t[i] ^ ctx->EKi.t[i];
1151                 GCM_MUL(ctx, Xi);
1152                 out += 16;
1153                 in += 16;
1154                 len -= 16;
1155             }
1156 # endif
1157             if (len) {
1158                 (*block) (ctx->Yi.c, ctx->EKi.c, key);
1159                 ++ctr;
1160                 if (is_endian.little)
1161 # ifdef BSWAP4
1162                     ctx->Yi.d[3] = BSWAP4(ctr);
1163 # else
1164                     PUTU32(ctx->Yi.c + 12, ctr);
1165 # endif
1166                 else
1167                     ctx->Yi.d[3] = ctr;
1168                 while (len--) {
1169                     ctx->Xi.c[n] ^= out[n] = in[n] ^ ctx->EKi.c[n];
1170                     ++n;
1171                 }
1172             }
1173
1174             ctx->mres = n;
1175             return 0;
1176         } while (0);
1177     }
1178 #endif
1179     for (i = 0; i < len; ++i) {
1180         if (n == 0) {
1181             (*block) (ctx->Yi.c, ctx->EKi.c, key);
1182             ++ctr;
1183             if (is_endian.little)
1184 #ifdef BSWAP4
1185                 ctx->Yi.d[3] = BSWAP4(ctr);
1186 #else
1187                 PUTU32(ctx->Yi.c + 12, ctr);
1188 #endif
1189             else
1190                 ctx->Yi.d[3] = ctr;
1191         }
1192         ctx->Xi.c[n] ^= out[i] = in[i] ^ ctx->EKi.c[n];
1193         n = (n + 1) % 16;
1194         if (n == 0)
1195             GCM_MUL(ctx, Xi);
1196     }
1197
1198     ctx->mres = n;
1199     return 0;
1200 }
1201
1202 int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx,
1203                           const unsigned char *in, unsigned char *out,
1204                           size_t len)
1205 {
1206     const union {
1207         long one;
1208         char little;
1209     } is_endian = { 1 };
1210     unsigned int n, ctr;
1211     size_t i;
1212     u64 mlen = ctx->len.u[1];
1213     block128_f block = ctx->block;
1214     void *key = ctx->key;
1215 #ifdef GCM_FUNCREF_4BIT
1216     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
1217 # if defined(GHASH) && !defined(OPENSSL_SMALL_FOOTPRINT)
1218     void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
1219                          const u8 *inp, size_t len) = ctx->ghash;
1220 # endif
1221 #endif
1222
1223     mlen += len;
1224     if (mlen > ((U64(1) << 36) - 32) || (sizeof(len) == 8 && mlen < len))
1225         return -1;
1226     ctx->len.u[1] = mlen;
1227
1228     if (ctx->ares) {
1229         /* First call to decrypt finalizes GHASH(AAD) */
1230         GCM_MUL(ctx, Xi);
1231         ctx->ares = 0;
1232     }
1233
1234     if (is_endian.little)
1235 #ifdef BSWAP4
1236         ctr = BSWAP4(ctx->Yi.d[3]);
1237 #else
1238         ctr = GETU32(ctx->Yi.c + 12);
1239 #endif
1240     else
1241         ctr = ctx->Yi.d[3];
1242
1243     n = ctx->mres;
1244 #if !defined(OPENSSL_SMALL_FOOTPRINT)
1245     if (16 % sizeof(size_t) == 0) { /* always true actually */
1246         do {
1247             if (n) {
1248                 while (n && len) {
1249                     u8 c = *(in++);
1250                     *(out++) = c ^ ctx->EKi.c[n];
1251                     ctx->Xi.c[n] ^= c;
1252                     --len;
1253                     n = (n + 1) % 16;
1254                 }
1255                 if (n == 0)
1256                     GCM_MUL(ctx, Xi);
1257                 else {
1258                     ctx->mres = n;
1259                     return 0;
1260                 }
1261             }
1262 # if defined(STRICT_ALIGNMENT)
1263             if (((size_t)in | (size_t)out) % sizeof(size_t) != 0)
1264                 break;
1265 # endif
1266 # if defined(GHASH)
1267 #  if defined(GHASH_CHUNK)
1268             while (len >= GHASH_CHUNK) {
1269                 size_t j = GHASH_CHUNK;
1270
1271                 GHASH(ctx, in, GHASH_CHUNK);
1272                 while (j) {
1273                     size_t *out_t = (size_t *)out;
1274                     const size_t *in_t = (const size_t *)in;
1275
1276                     (*block) (ctx->Yi.c, ctx->EKi.c, key);
1277                     ++ctr;
1278                     if (is_endian.little)
1279 #   ifdef BSWAP4
1280                         ctx->Yi.d[3] = BSWAP4(ctr);
1281 #   else
1282                         PUTU32(ctx->Yi.c + 12, ctr);
1283 #   endif
1284                     else
1285                         ctx->Yi.d[3] = ctr;
1286                     for (i = 0; i < 16 / sizeof(size_t); ++i)
1287                         out_t[i] = in_t[i] ^ ctx->EKi.t[i];
1288                     out += 16;
1289                     in += 16;
1290                     j -= 16;
1291                 }
1292                 len -= GHASH_CHUNK;
1293             }
1294 #  endif
1295             if ((i = (len & (size_t)-16))) {
1296                 GHASH(ctx, in, i);
1297                 while (len >= 16) {
1298                     size_t *out_t = (size_t *)out;
1299                     const size_t *in_t = (const size_t *)in;
1300
1301                     (*block) (ctx->Yi.c, ctx->EKi.c, key);
1302                     ++ctr;
1303                     if (is_endian.little)
1304 #  ifdef BSWAP4
1305                         ctx->Yi.d[3] = BSWAP4(ctr);
1306 #  else
1307                         PUTU32(ctx->Yi.c + 12, ctr);
1308 #  endif
1309                     else
1310                         ctx->Yi.d[3] = ctr;
1311                     for (i = 0; i < 16 / sizeof(size_t); ++i)
1312                         out_t[i] = in_t[i] ^ ctx->EKi.t[i];
1313                     out += 16;
1314                     in += 16;
1315                     len -= 16;
1316                 }
1317             }
1318 # else
1319             while (len >= 16) {
1320                 size_t *out_t = (size_t *)out;
1321                 const size_t *in_t = (const size_t *)in;
1322
1323                 (*block) (ctx->Yi.c, ctx->EKi.c, key);
1324                 ++ctr;
1325                 if (is_endian.little)
1326 #  ifdef BSWAP4
1327                     ctx->Yi.d[3] = BSWAP4(ctr);
1328 #  else
1329                     PUTU32(ctx->Yi.c + 12, ctr);
1330 #  endif
1331                 else
1332                     ctx->Yi.d[3] = ctr;
1333                 for (i = 0; i < 16 / sizeof(size_t); ++i) {
1334                     size_t c = in[i];
1335                     out[i] = c ^ ctx->EKi.t[i];
1336                     ctx->Xi.t[i] ^= c;
1337                 }
1338                 GCM_MUL(ctx, Xi);
1339                 out += 16;
1340                 in += 16;
1341                 len -= 16;
1342             }
1343 # endif
1344             if (len) {
1345                 (*block) (ctx->Yi.c, ctx->EKi.c, key);
1346                 ++ctr;
1347                 if (is_endian.little)
1348 # ifdef BSWAP4
1349                     ctx->Yi.d[3] = BSWAP4(ctr);
1350 # else
1351                     PUTU32(ctx->Yi.c + 12, ctr);
1352 # endif
1353                 else
1354                     ctx->Yi.d[3] = ctr;
1355                 while (len--) {
1356                     u8 c = in[n];
1357                     ctx->Xi.c[n] ^= c;
1358                     out[n] = c ^ ctx->EKi.c[n];
1359                     ++n;
1360                 }
1361             }
1362
1363             ctx->mres = n;
1364             return 0;
1365         } while (0);
1366     }
1367 #endif
1368     for (i = 0; i < len; ++i) {
1369         u8 c;
1370         if (n == 0) {
1371             (*block) (ctx->Yi.c, ctx->EKi.c, key);
1372             ++ctr;
1373             if (is_endian.little)
1374 #ifdef BSWAP4
1375                 ctx->Yi.d[3] = BSWAP4(ctr);
1376 #else
1377                 PUTU32(ctx->Yi.c + 12, ctr);
1378 #endif
1379             else
1380                 ctx->Yi.d[3] = ctr;
1381         }
1382         c = in[i];
1383         out[i] = c ^ ctx->EKi.c[n];
1384         ctx->Xi.c[n] ^= c;
1385         n = (n + 1) % 16;
1386         if (n == 0)
1387             GCM_MUL(ctx, Xi);
1388     }
1389
1390     ctx->mres = n;
1391     return 0;
1392 }
1393
1394 int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx,
1395                                 const unsigned char *in, unsigned char *out,
1396                                 size_t len, ctr128_f stream)
1397 {
1398 #if defined(OPENSSL_SMALL_FOOTPRINT)
1399     return CRYPTO_gcm128_encrypt(ctx, in, out, len);
1400 #else
1401     const union {
1402         long one;
1403         char little;
1404     } is_endian = { 1 };
1405     unsigned int n, ctr;
1406     size_t i;
1407     u64 mlen = ctx->len.u[1];
1408     void *key = ctx->key;
1409 # ifdef GCM_FUNCREF_4BIT
1410     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
1411 #  ifdef GHASH
1412     void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
1413                          const u8 *inp, size_t len) = ctx->ghash;
1414 #  endif
1415 # endif
1416
1417     mlen += len;
1418     if (mlen > ((U64(1) << 36) - 32) || (sizeof(len) == 8 && mlen < len))
1419         return -1;
1420     ctx->len.u[1] = mlen;
1421
1422     if (ctx->ares) {
1423         /* First call to encrypt finalizes GHASH(AAD) */
1424         GCM_MUL(ctx, Xi);
1425         ctx->ares = 0;
1426     }
1427
1428     if (is_endian.little)
1429 # ifdef BSWAP4
1430         ctr = BSWAP4(ctx->Yi.d[3]);
1431 # else
1432         ctr = GETU32(ctx->Yi.c + 12);
1433 # endif
1434     else
1435         ctr = ctx->Yi.d[3];
1436
1437     n = ctx->mres;
1438     if (n) {
1439         while (n && len) {
1440             ctx->Xi.c[n] ^= *(out++) = *(in++) ^ ctx->EKi.c[n];
1441             --len;
1442             n = (n + 1) % 16;
1443         }
1444         if (n == 0)
1445             GCM_MUL(ctx, Xi);
1446         else {
1447             ctx->mres = n;
1448             return 0;
1449         }
1450     }
1451 # if defined(GHASH) && defined(GHASH_CHUNK)
1452     while (len >= GHASH_CHUNK) {
1453         (*stream) (in, out, GHASH_CHUNK / 16, key, ctx->Yi.c);
1454         ctr += GHASH_CHUNK / 16;
1455         if (is_endian.little)
1456 #  ifdef BSWAP4
1457             ctx->Yi.d[3] = BSWAP4(ctr);
1458 #  else
1459             PUTU32(ctx->Yi.c + 12, ctr);
1460 #  endif
1461         else
1462             ctx->Yi.d[3] = ctr;
1463         GHASH(ctx, out, GHASH_CHUNK);
1464         out += GHASH_CHUNK;
1465         in += GHASH_CHUNK;
1466         len -= GHASH_CHUNK;
1467     }
1468 # endif
1469     if ((i = (len & (size_t)-16))) {
1470         size_t j = i / 16;
1471
1472         (*stream) (in, out, j, key, ctx->Yi.c);
1473         ctr += (unsigned int)j;
1474         if (is_endian.little)
1475 # ifdef BSWAP4
1476             ctx->Yi.d[3] = BSWAP4(ctr);
1477 # else
1478             PUTU32(ctx->Yi.c + 12, ctr);
1479 # endif
1480         else
1481             ctx->Yi.d[3] = ctr;
1482         in += i;
1483         len -= i;
1484 # if defined(GHASH)
1485         GHASH(ctx, out, i);
1486         out += i;
1487 # else
1488         while (j--) {
1489             for (i = 0; i < 16; ++i)
1490                 ctx->Xi.c[i] ^= out[i];
1491             GCM_MUL(ctx, Xi);
1492             out += 16;
1493         }
1494 # endif
1495     }
1496     if (len) {
1497         (*ctx->block) (ctx->Yi.c, ctx->EKi.c, key);
1498         ++ctr;
1499         if (is_endian.little)
1500 # ifdef BSWAP4
1501             ctx->Yi.d[3] = BSWAP4(ctr);
1502 # else
1503             PUTU32(ctx->Yi.c + 12, ctr);
1504 # endif
1505         else
1506             ctx->Yi.d[3] = ctr;
1507         while (len--) {
1508             ctx->Xi.c[n] ^= out[n] = in[n] ^ ctx->EKi.c[n];
1509             ++n;
1510         }
1511     }
1512
1513     ctx->mres = n;
1514     return 0;
1515 #endif
1516 }
1517
1518 int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx,
1519                                 const unsigned char *in, unsigned char *out,
1520                                 size_t len, ctr128_f stream)
1521 {
1522 #if defined(OPENSSL_SMALL_FOOTPRINT)
1523     return CRYPTO_gcm128_decrypt(ctx, in, out, len);
1524 #else
1525     const union {
1526         long one;
1527         char little;
1528     } is_endian = { 1 };
1529     unsigned int n, ctr;
1530     size_t i;
1531     u64 mlen = ctx->len.u[1];
1532     void *key = ctx->key;
1533 # ifdef GCM_FUNCREF_4BIT
1534     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
1535 #  ifdef GHASH
1536     void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
1537                          const u8 *inp, size_t len) = ctx->ghash;
1538 #  endif
1539 # endif
1540
1541     mlen += len;
1542     if (mlen > ((U64(1) << 36) - 32) || (sizeof(len) == 8 && mlen < len))
1543         return -1;
1544     ctx->len.u[1] = mlen;
1545
1546     if (ctx->ares) {
1547         /* First call to decrypt finalizes GHASH(AAD) */
1548         GCM_MUL(ctx, Xi);
1549         ctx->ares = 0;
1550     }
1551
1552     if (is_endian.little)
1553 # ifdef BSWAP4
1554         ctr = BSWAP4(ctx->Yi.d[3]);
1555 # else
1556         ctr = GETU32(ctx->Yi.c + 12);
1557 # endif
1558     else
1559         ctr = ctx->Yi.d[3];
1560
1561     n = ctx->mres;
1562     if (n) {
1563         while (n && len) {
1564             u8 c = *(in++);
1565             *(out++) = c ^ ctx->EKi.c[n];
1566             ctx->Xi.c[n] ^= c;
1567             --len;
1568             n = (n + 1) % 16;
1569         }
1570         if (n == 0)
1571             GCM_MUL(ctx, Xi);
1572         else {
1573             ctx->mres = n;
1574             return 0;
1575         }
1576     }
1577 # if defined(GHASH) && defined(GHASH_CHUNK)
1578     while (len >= GHASH_CHUNK) {
1579         GHASH(ctx, in, GHASH_CHUNK);
1580         (*stream) (in, out, GHASH_CHUNK / 16, key, ctx->Yi.c);
1581         ctr += GHASH_CHUNK / 16;
1582         if (is_endian.little)
1583 #  ifdef BSWAP4
1584             ctx->Yi.d[3] = BSWAP4(ctr);
1585 #  else
1586             PUTU32(ctx->Yi.c + 12, ctr);
1587 #  endif
1588         else
1589             ctx->Yi.d[3] = ctr;
1590         out += GHASH_CHUNK;
1591         in += GHASH_CHUNK;
1592         len -= GHASH_CHUNK;
1593     }
1594 # endif
1595     if ((i = (len & (size_t)-16))) {
1596         size_t j = i / 16;
1597
1598 # if defined(GHASH)
1599         GHASH(ctx, in, i);
1600 # else
1601         while (j--) {
1602             size_t k;
1603             for (k = 0; k < 16; ++k)
1604                 ctx->Xi.c[k] ^= in[k];
1605             GCM_MUL(ctx, Xi);
1606             in += 16;
1607         }
1608         j = i / 16;
1609         in -= i;
1610 # endif
1611         (*stream) (in, out, j, key, ctx->Yi.c);
1612         ctr += (unsigned int)j;
1613         if (is_endian.little)
1614 # ifdef BSWAP4
1615             ctx->Yi.d[3] = BSWAP4(ctr);
1616 # else
1617             PUTU32(ctx->Yi.c + 12, ctr);
1618 # endif
1619         else
1620             ctx->Yi.d[3] = ctr;
1621         out += i;
1622         in += i;
1623         len -= i;
1624     }
1625     if (len) {
1626         (*ctx->block) (ctx->Yi.c, ctx->EKi.c, key);
1627         ++ctr;
1628         if (is_endian.little)
1629 # ifdef BSWAP4
1630             ctx->Yi.d[3] = BSWAP4(ctr);
1631 # else
1632             PUTU32(ctx->Yi.c + 12, ctr);
1633 # endif
1634         else
1635             ctx->Yi.d[3] = ctr;
1636         while (len--) {
1637             u8 c = in[n];
1638             ctx->Xi.c[n] ^= c;
1639             out[n] = c ^ ctx->EKi.c[n];
1640             ++n;
1641         }
1642     }
1643
1644     ctx->mres = n;
1645     return 0;
1646 #endif
1647 }
1648
1649 int CRYPTO_gcm128_finish(GCM128_CONTEXT *ctx, const unsigned char *tag,
1650                          size_t len)
1651 {
1652     const union {
1653         long one;
1654         char little;
1655     } is_endian = { 1 };
1656     u64 alen = ctx->len.u[0] << 3;
1657     u64 clen = ctx->len.u[1] << 3;
1658 #ifdef GCM_FUNCREF_4BIT
1659     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
1660 #endif
1661
1662     if (ctx->mres || ctx->ares)
1663         GCM_MUL(ctx, Xi);
1664
1665     if (is_endian.little) {
1666 #ifdef BSWAP8
1667         alen = BSWAP8(alen);
1668         clen = BSWAP8(clen);
1669 #else
1670         u8 *p = ctx->len.c;
1671
1672         ctx->len.u[0] = alen;
1673         ctx->len.u[1] = clen;
1674
1675         alen = (u64)GETU32(p) << 32 | GETU32(p + 4);
1676         clen = (u64)GETU32(p + 8) << 32 | GETU32(p + 12);
1677 #endif
1678     }
1679
1680     ctx->Xi.u[0] ^= alen;
1681     ctx->Xi.u[1] ^= clen;
1682     GCM_MUL(ctx, Xi);
1683
1684     ctx->Xi.u[0] ^= ctx->EK0.u[0];
1685     ctx->Xi.u[1] ^= ctx->EK0.u[1];
1686
1687     if (tag && len <= sizeof(ctx->Xi))
1688         return memcmp(ctx->Xi.c, tag, len);
1689     else
1690         return -1;
1691 }
1692
1693 void CRYPTO_gcm128_tag(GCM128_CONTEXT *ctx, unsigned char *tag, size_t len)
1694 {
1695     CRYPTO_gcm128_finish(ctx, NULL, 0);
1696     memcpy(tag, ctx->Xi.c,
1697            len <= sizeof(ctx->Xi.c) ? len : sizeof(ctx->Xi.c));
1698 }
1699
1700 GCM128_CONTEXT *CRYPTO_gcm128_new(void *key, block128_f block)
1701 {
1702     GCM128_CONTEXT *ret;
1703
1704     if ((ret = OPENSSL_malloc(sizeof(GCM128_CONTEXT))))
1705         CRYPTO_gcm128_init(ret, key, block);
1706
1707     return ret;
1708 }
1709
1710 void CRYPTO_gcm128_release(GCM128_CONTEXT *ctx)
1711 {
1712     if (ctx) {
1713         OPENSSL_cleanse(ctx, sizeof(*ctx));
1714         OPENSSL_free(ctx);
1715     }
1716 }
1717
1718 #if defined(SELFTEST)
1719 # include <stdio.h>
1720 # include <openssl/aes.h>
1721
1722 /* Test Case 1 */
1723 static const u8 K1[16], *P1 = NULL, *A1 = NULL, IV1[12], *C1 = NULL;
1724 static const u8 T1[] = {
1725     0x58, 0xe2, 0xfc, 0xce, 0xfa, 0x7e, 0x30, 0x61,
1726     0x36, 0x7f, 0x1d, 0x57, 0xa4, 0xe7, 0x45, 0x5a
1727 };
1728
1729 /* Test Case 2 */
1730 # define K2 K1
1731 # define A2 A1
1732 # define IV2 IV1
1733 static const u8 P2[16];
1734 static const u8 C2[] = {
1735     0x03, 0x88, 0xda, 0xce, 0x60, 0xb6, 0xa3, 0x92,
1736     0xf3, 0x28, 0xc2, 0xb9, 0x71, 0xb2, 0xfe, 0x78
1737 };
1738
1739 static const u8 T2[] = {
1740     0xab, 0x6e, 0x47, 0xd4, 0x2c, 0xec, 0x13, 0xbd,
1741     0xf5, 0x3a, 0x67, 0xb2, 0x12, 0x57, 0xbd, 0xdf
1742 };
1743
1744 /* Test Case 3 */
1745 # define A3 A2
1746 static const u8 K3[] = {
1747     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
1748     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08
1749 };
1750
1751 static const u8 P3[] = {
1752     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
1753     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
1754     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
1755     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
1756     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
1757     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
1758     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
1759     0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55
1760 };
1761
1762 static const u8 IV3[] = {
1763     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
1764     0xde, 0xca, 0xf8, 0x88
1765 };
1766
1767 static const u8 C3[] = {
1768     0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24,
1769     0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c,
1770     0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0,
1771     0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e,
1772     0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c,
1773     0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05,
1774     0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97,
1775     0x3d, 0x58, 0xe0, 0x91, 0x47, 0x3f, 0x59, 0x85
1776 };
1777
1778 static const u8 T3[] = {
1779     0x4d, 0x5c, 0x2a, 0xf3, 0x27, 0xcd, 0x64, 0xa6,
1780     0x2c, 0xf3, 0x5a, 0xbd, 0x2b, 0xa6, 0xfa, 0xb4
1781 };
1782
1783 /* Test Case 4 */
1784 # define K4 K3
1785 # define IV4 IV3
1786 static const u8 P4[] = {
1787     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
1788     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
1789     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
1790     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
1791     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
1792     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
1793     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
1794     0xba, 0x63, 0x7b, 0x39
1795 };
1796
1797 static const u8 A4[] = {
1798     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
1799     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
1800     0xab, 0xad, 0xda, 0xd2
1801 };
1802
1803 static const u8 C4[] = {
1804     0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24,
1805     0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c,
1806     0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0,
1807     0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e,
1808     0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c,
1809     0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05,
1810     0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97,
1811     0x3d, 0x58, 0xe0, 0x91
1812 };
1813
1814 static const u8 T4[] = {
1815     0x5b, 0xc9, 0x4f, 0xbc, 0x32, 0x21, 0xa5, 0xdb,
1816     0x94, 0xfa, 0xe9, 0x5a, 0xe7, 0x12, 0x1a, 0x47
1817 };
1818
1819 /* Test Case 5 */
1820 # define K5 K4
1821 # define P5 P4
1822 # define A5 A4
1823 static const u8 IV5[] = {
1824     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad
1825 };
1826
1827 static const u8 C5[] = {
1828     0x61, 0x35, 0x3b, 0x4c, 0x28, 0x06, 0x93, 0x4a,
1829     0x77, 0x7f, 0xf5, 0x1f, 0xa2, 0x2a, 0x47, 0x55,
1830     0x69, 0x9b, 0x2a, 0x71, 0x4f, 0xcd, 0xc6, 0xf8,
1831     0x37, 0x66, 0xe5, 0xf9, 0x7b, 0x6c, 0x74, 0x23,
1832     0x73, 0x80, 0x69, 0x00, 0xe4, 0x9f, 0x24, 0xb2,
1833     0x2b, 0x09, 0x75, 0x44, 0xd4, 0x89, 0x6b, 0x42,
1834     0x49, 0x89, 0xb5, 0xe1, 0xeb, 0xac, 0x0f, 0x07,
1835     0xc2, 0x3f, 0x45, 0x98
1836 };
1837
1838 static const u8 T5[] = {
1839     0x36, 0x12, 0xd2, 0xe7, 0x9e, 0x3b, 0x07, 0x85,
1840     0x56, 0x1b, 0xe1, 0x4a, 0xac, 0xa2, 0xfc, 0xcb
1841 };
1842
1843 /* Test Case 6 */
1844 # define K6 K5
1845 # define P6 P5
1846 # define A6 A5
1847 static const u8 IV6[] = {
1848     0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
1849     0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
1850     0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
1851     0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
1852     0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
1853     0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
1854     0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
1855     0xa6, 0x37, 0xb3, 0x9b
1856 };
1857
1858 static const u8 C6[] = {
1859     0x8c, 0xe2, 0x49, 0x98, 0x62, 0x56, 0x15, 0xb6,
1860     0x03, 0xa0, 0x33, 0xac, 0xa1, 0x3f, 0xb8, 0x94,
1861     0xbe, 0x91, 0x12, 0xa5, 0xc3, 0xa2, 0x11, 0xa8,
1862     0xba, 0x26, 0x2a, 0x3c, 0xca, 0x7e, 0x2c, 0xa7,
1863     0x01, 0xe4, 0xa9, 0xa4, 0xfb, 0xa4, 0x3c, 0x90,
1864     0xcc, 0xdc, 0xb2, 0x81, 0xd4, 0x8c, 0x7c, 0x6f,
1865     0xd6, 0x28, 0x75, 0xd2, 0xac, 0xa4, 0x17, 0x03,
1866     0x4c, 0x34, 0xae, 0xe5
1867 };
1868
1869 static const u8 T6[] = {
1870     0x61, 0x9c, 0xc5, 0xae, 0xff, 0xfe, 0x0b, 0xfa,
1871     0x46, 0x2a, 0xf4, 0x3c, 0x16, 0x99, 0xd0, 0x50
1872 };
1873
1874 /* Test Case 7 */
1875 static const u8 K7[24], *P7 = NULL, *A7 = NULL, IV7[12], *C7 = NULL;
1876 static const u8 T7[] = {
1877     0xcd, 0x33, 0xb2, 0x8a, 0xc7, 0x73, 0xf7, 0x4b,
1878     0xa0, 0x0e, 0xd1, 0xf3, 0x12, 0x57, 0x24, 0x35
1879 };
1880
1881 /* Test Case 8 */
1882 # define K8 K7
1883 # define IV8 IV7
1884 # define A8 A7
1885 static const u8 P8[16];
1886 static const u8 C8[] = {
1887     0x98, 0xe7, 0x24, 0x7c, 0x07, 0xf0, 0xfe, 0x41,
1888     0x1c, 0x26, 0x7e, 0x43, 0x84, 0xb0, 0xf6, 0x00
1889 };
1890
1891 static const u8 T8[] = {
1892     0x2f, 0xf5, 0x8d, 0x80, 0x03, 0x39, 0x27, 0xab,
1893     0x8e, 0xf4, 0xd4, 0x58, 0x75, 0x14, 0xf0, 0xfb
1894 };
1895
1896 /* Test Case 9 */
1897 # define A9 A8
1898 static const u8 K9[] = {
1899     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
1900     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08,
1901     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c
1902 };
1903
1904 static const u8 P9[] = {
1905     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
1906     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
1907     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
1908     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
1909     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
1910     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
1911     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
1912     0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55
1913 };
1914
1915 static const u8 IV9[] = {
1916     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
1917     0xde, 0xca, 0xf8, 0x88
1918 };
1919
1920 static const u8 C9[] = {
1921     0x39, 0x80, 0xca, 0x0b, 0x3c, 0x00, 0xe8, 0x41,
1922     0xeb, 0x06, 0xfa, 0xc4, 0x87, 0x2a, 0x27, 0x57,
1923     0x85, 0x9e, 0x1c, 0xea, 0xa6, 0xef, 0xd9, 0x84,
1924     0x62, 0x85, 0x93, 0xb4, 0x0c, 0xa1, 0xe1, 0x9c,
1925     0x7d, 0x77, 0x3d, 0x00, 0xc1, 0x44, 0xc5, 0x25,
1926     0xac, 0x61, 0x9d, 0x18, 0xc8, 0x4a, 0x3f, 0x47,
1927     0x18, 0xe2, 0x44, 0x8b, 0x2f, 0xe3, 0x24, 0xd9,
1928     0xcc, 0xda, 0x27, 0x10, 0xac, 0xad, 0xe2, 0x56
1929 };
1930
1931 static const u8 T9[] = {
1932     0x99, 0x24, 0xa7, 0xc8, 0x58, 0x73, 0x36, 0xbf,
1933     0xb1, 0x18, 0x02, 0x4d, 0xb8, 0x67, 0x4a, 0x14
1934 };
1935
1936 /* Test Case 10 */
1937 # define K10 K9
1938 # define IV10 IV9
1939 static const u8 P10[] = {
1940     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
1941     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
1942     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
1943     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
1944     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
1945     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
1946     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
1947     0xba, 0x63, 0x7b, 0x39
1948 };
1949
1950 static const u8 A10[] = {
1951     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
1952     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
1953     0xab, 0xad, 0xda, 0xd2
1954 };
1955
1956 static const u8 C10[] = {
1957     0x39, 0x80, 0xca, 0x0b, 0x3c, 0x00, 0xe8, 0x41,
1958     0xeb, 0x06, 0xfa, 0xc4, 0x87, 0x2a, 0x27, 0x57,
1959     0x85, 0x9e, 0x1c, 0xea, 0xa6, 0xef, 0xd9, 0x84,
1960     0x62, 0x85, 0x93, 0xb4, 0x0c, 0xa1, 0xe1, 0x9c,
1961     0x7d, 0x77, 0x3d, 0x00, 0xc1, 0x44, 0xc5, 0x25,
1962     0xac, 0x61, 0x9d, 0x18, 0xc8, 0x4a, 0x3f, 0x47,
1963     0x18, 0xe2, 0x44, 0x8b, 0x2f, 0xe3, 0x24, 0xd9,
1964     0xcc, 0xda, 0x27, 0x10
1965 };
1966
1967 static const u8 T10[] = {
1968     0x25, 0x19, 0x49, 0x8e, 0x80, 0xf1, 0x47, 0x8f,
1969     0x37, 0xba, 0x55, 0xbd, 0x6d, 0x27, 0x61, 0x8c
1970 };
1971
1972 /* Test Case 11 */
1973 # define K11 K10
1974 # define P11 P10
1975 # define A11 A10
1976 static const u8 IV11[] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad };
1977
1978 static const u8 C11[] = {
1979     0x0f, 0x10, 0xf5, 0x99, 0xae, 0x14, 0xa1, 0x54,
1980     0xed, 0x24, 0xb3, 0x6e, 0x25, 0x32, 0x4d, 0xb8,
1981     0xc5, 0x66, 0x63, 0x2e, 0xf2, 0xbb, 0xb3, 0x4f,
1982     0x83, 0x47, 0x28, 0x0f, 0xc4, 0x50, 0x70, 0x57,
1983     0xfd, 0xdc, 0x29, 0xdf, 0x9a, 0x47, 0x1f, 0x75,
1984     0xc6, 0x65, 0x41, 0xd4, 0xd4, 0xda, 0xd1, 0xc9,
1985     0xe9, 0x3a, 0x19, 0xa5, 0x8e, 0x8b, 0x47, 0x3f,
1986     0xa0, 0xf0, 0x62, 0xf7
1987 };
1988
1989 static const u8 T11[] = {
1990     0x65, 0xdc, 0xc5, 0x7f, 0xcf, 0x62, 0x3a, 0x24,
1991     0x09, 0x4f, 0xcc, 0xa4, 0x0d, 0x35, 0x33, 0xf8
1992 };
1993
1994 /* Test Case 12 */
1995 # define K12 K11
1996 # define P12 P11
1997 # define A12 A11
1998 static const u8 IV12[] = {
1999     0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
2000     0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
2001     0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
2002     0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
2003     0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
2004     0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
2005     0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
2006     0xa6, 0x37, 0xb3, 0x9b
2007 };
2008
2009 static const u8 C12[] = {
2010     0xd2, 0x7e, 0x88, 0x68, 0x1c, 0xe3, 0x24, 0x3c,
2011     0x48, 0x30, 0x16, 0x5a, 0x8f, 0xdc, 0xf9, 0xff,
2012     0x1d, 0xe9, 0xa1, 0xd8, 0xe6, 0xb4, 0x47, 0xef,
2013     0x6e, 0xf7, 0xb7, 0x98, 0x28, 0x66, 0x6e, 0x45,
2014     0x81, 0xe7, 0x90, 0x12, 0xaf, 0x34, 0xdd, 0xd9,
2015     0xe2, 0xf0, 0x37, 0x58, 0x9b, 0x29, 0x2d, 0xb3,
2016     0xe6, 0x7c, 0x03, 0x67, 0x45, 0xfa, 0x22, 0xe7,
2017     0xe9, 0xb7, 0x37, 0x3b
2018 };
2019
2020 static const u8 T12[] = {
2021     0xdc, 0xf5, 0x66, 0xff, 0x29, 0x1c, 0x25, 0xbb,
2022     0xb8, 0x56, 0x8f, 0xc3, 0xd3, 0x76, 0xa6, 0xd9
2023 };
2024
2025 /* Test Case 13 */
2026 static const u8 K13[32], *P13 = NULL, *A13 = NULL, IV13[12], *C13 = NULL;
2027 static const u8 T13[] = {
2028     0x53, 0x0f, 0x8a, 0xfb, 0xc7, 0x45, 0x36, 0xb9,
2029     0xa9, 0x63, 0xb4, 0xf1, 0xc4, 0xcb, 0x73, 0x8b
2030 };
2031
2032 /* Test Case 14 */
2033 # define K14 K13
2034 # define A14 A13
2035 static const u8 P14[16], IV14[12];
2036 static const u8 C14[] = {
2037     0xce, 0xa7, 0x40, 0x3d, 0x4d, 0x60, 0x6b, 0x6e,
2038     0x07, 0x4e, 0xc5, 0xd3, 0xba, 0xf3, 0x9d, 0x18
2039 };
2040
2041 static const u8 T14[] = {
2042     0xd0, 0xd1, 0xc8, 0xa7, 0x99, 0x99, 0x6b, 0xf0,
2043     0x26, 0x5b, 0x98, 0xb5, 0xd4, 0x8a, 0xb9, 0x19
2044 };
2045
2046 /* Test Case 15 */
2047 # define A15 A14
2048 static const u8 K15[] = {
2049     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
2050     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08,
2051     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
2052     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08
2053 };
2054
2055 static const u8 P15[] = {
2056     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
2057     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
2058     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
2059     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
2060     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
2061     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
2062     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
2063     0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55
2064 };
2065
2066 static const u8 IV15[] = {
2067     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
2068     0xde, 0xca, 0xf8, 0x88
2069 };
2070
2071 static const u8 C15[] = {
2072     0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
2073     0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
2074     0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
2075     0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
2076     0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
2077     0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
2078     0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
2079     0xbc, 0xc9, 0xf6, 0x62, 0x89, 0x80, 0x15, 0xad
2080 };
2081
2082 static const u8 T15[] = {
2083     0xb0, 0x94, 0xda, 0xc5, 0xd9, 0x34, 0x71, 0xbd,
2084     0xec, 0x1a, 0x50, 0x22, 0x70, 0xe3, 0xcc, 0x6c
2085 };
2086
2087 /* Test Case 16 */
2088 # define K16 K15
2089 # define IV16 IV15
2090 static const u8 P16[] = {
2091     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
2092     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
2093     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
2094     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
2095     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
2096     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
2097     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
2098     0xba, 0x63, 0x7b, 0x39
2099 };
2100
2101 static const u8 A16[] = {
2102     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
2103     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
2104     0xab, 0xad, 0xda, 0xd2
2105 };
2106
2107 static const u8 C16[] = {
2108     0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
2109     0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
2110     0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
2111     0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
2112     0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
2113     0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
2114     0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
2115     0xbc, 0xc9, 0xf6, 0x62
2116 };
2117
2118 static const u8 T16[] = {
2119     0x76, 0xfc, 0x6e, 0xce, 0x0f, 0x4e, 0x17, 0x68,
2120     0xcd, 0xdf, 0x88, 0x53, 0xbb, 0x2d, 0x55, 0x1b
2121 };
2122
2123 /* Test Case 17 */
2124 # define K17 K16
2125 # define P17 P16
2126 # define A17 A16
2127 static const u8 IV17[] = { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad };
2128
2129 static const u8 C17[] = {
2130     0xc3, 0x76, 0x2d, 0xf1, 0xca, 0x78, 0x7d, 0x32,
2131     0xae, 0x47, 0xc1, 0x3b, 0xf1, 0x98, 0x44, 0xcb,
2132     0xaf, 0x1a, 0xe1, 0x4d, 0x0b, 0x97, 0x6a, 0xfa,
2133     0xc5, 0x2f, 0xf7, 0xd7, 0x9b, 0xba, 0x9d, 0xe0,
2134     0xfe, 0xb5, 0x82, 0xd3, 0x39, 0x34, 0xa4, 0xf0,
2135     0x95, 0x4c, 0xc2, 0x36, 0x3b, 0xc7, 0x3f, 0x78,
2136     0x62, 0xac, 0x43, 0x0e, 0x64, 0xab, 0xe4, 0x99,
2137     0xf4, 0x7c, 0x9b, 0x1f
2138 };
2139
2140 static const u8 T17[] = {
2141     0x3a, 0x33, 0x7d, 0xbf, 0x46, 0xa7, 0x92, 0xc4,
2142     0x5e, 0x45, 0x49, 0x13, 0xfe, 0x2e, 0xa8, 0xf2
2143 };
2144
2145 /* Test Case 18 */
2146 # define K18 K17
2147 # define P18 P17
2148 # define A18 A17
2149 static const u8 IV18[] = {
2150     0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
2151     0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
2152     0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
2153     0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
2154     0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
2155     0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
2156     0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
2157     0xa6, 0x37, 0xb3, 0x9b
2158 };
2159
2160 static const u8 C18[] = {
2161     0x5a, 0x8d, 0xef, 0x2f, 0x0c, 0x9e, 0x53, 0xf1,
2162     0xf7, 0x5d, 0x78, 0x53, 0x65, 0x9e, 0x2a, 0x20,
2163     0xee, 0xb2, 0xb2, 0x2a, 0xaf, 0xde, 0x64, 0x19,
2164     0xa0, 0x58, 0xab, 0x4f, 0x6f, 0x74, 0x6b, 0xf4,
2165     0x0f, 0xc0, 0xc3, 0xb7, 0x80, 0xf2, 0x44, 0x45,
2166     0x2d, 0xa3, 0xeb, 0xf1, 0xc5, 0xd8, 0x2c, 0xde,
2167     0xa2, 0x41, 0x89, 0x97, 0x20, 0x0e, 0xf8, 0x2e,
2168     0x44, 0xae, 0x7e, 0x3f
2169 };
2170
2171 static const u8 T18[] = {
2172     0xa4, 0x4a, 0x82, 0x66, 0xee, 0x1c, 0x8e, 0xb0,
2173     0xc8, 0xb5, 0xd4, 0xcf, 0x5a, 0xe9, 0xf1, 0x9a
2174 };
2175
2176 /* Test Case 19 */
2177 # define K19 K1
2178 # define P19 P1
2179 # define IV19 IV1
2180 # define C19 C1
2181 static const u8 A19[] = {
2182     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
2183     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
2184     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
2185     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
2186     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
2187     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
2188     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
2189     0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55,
2190     0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07,
2191     0xf4, 0x7f, 0x37, 0xa3, 0x2a, 0x84, 0x42, 0x7d,
2192     0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
2193     0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa,
2194     0x8c, 0xb0, 0x8e, 0x48, 0x59, 0x0d, 0xbb, 0x3d,
2195     0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
2196     0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a,
2197     0xbc, 0xc9, 0xf6, 0x62, 0x89, 0x80, 0x15, 0xad
2198 };
2199
2200 static const u8 T19[] = {
2201     0x5f, 0xea, 0x79, 0x3a, 0x2d, 0x6f, 0x97, 0x4d,
2202     0x37, 0xe6, 0x8e, 0x0c, 0xb8, 0xff, 0x94, 0x92
2203 };
2204
2205 /* Test Case 20 */
2206 # define K20 K1
2207 # define A20 A1
2208 /* this results in 0xff in counter LSB */
2209 static const u8 IV20[64] = { 0xff, 0xff, 0xff, 0xff };
2210
2211 static const u8 P20[288];
2212 static const u8 C20[] = {
2213     0x56, 0xb3, 0x37, 0x3c, 0xa9, 0xef, 0x6e, 0x4a,
2214     0x2b, 0x64, 0xfe, 0x1e, 0x9a, 0x17, 0xb6, 0x14,
2215     0x25, 0xf1, 0x0d, 0x47, 0xa7, 0x5a, 0x5f, 0xce,
2216     0x13, 0xef, 0xc6, 0xbc, 0x78, 0x4a, 0xf2, 0x4f,
2217     0x41, 0x41, 0xbd, 0xd4, 0x8c, 0xf7, 0xc7, 0x70,
2218     0x88, 0x7a, 0xfd, 0x57, 0x3c, 0xca, 0x54, 0x18,
2219     0xa9, 0xae, 0xff, 0xcd, 0x7c, 0x5c, 0xed, 0xdf,
2220     0xc6, 0xa7, 0x83, 0x97, 0xb9, 0xa8, 0x5b, 0x49,
2221     0x9d, 0xa5, 0x58, 0x25, 0x72, 0x67, 0xca, 0xab,
2222     0x2a, 0xd0, 0xb2, 0x3c, 0xa4, 0x76, 0xa5, 0x3c,
2223     0xb1, 0x7f, 0xb4, 0x1c, 0x4b, 0x8b, 0x47, 0x5c,
2224     0xb4, 0xf3, 0xf7, 0x16, 0x50, 0x94, 0xc2, 0x29,
2225     0xc9, 0xe8, 0xc4, 0xdc, 0x0a, 0x2a, 0x5f, 0xf1,
2226     0x90, 0x3e, 0x50, 0x15, 0x11, 0x22, 0x13, 0x76,
2227     0xa1, 0xcd, 0xb8, 0x36, 0x4c, 0x50, 0x61, 0xa2,
2228     0x0c, 0xae, 0x74, 0xbc, 0x4a, 0xcd, 0x76, 0xce,
2229     0xb0, 0xab, 0xc9, 0xfd, 0x32, 0x17, 0xef, 0x9f,
2230     0x8c, 0x90, 0xbe, 0x40, 0x2d, 0xdf, 0x6d, 0x86,
2231     0x97, 0xf4, 0xf8, 0x80, 0xdf, 0xf1, 0x5b, 0xfb,
2232     0x7a, 0x6b, 0x28, 0x24, 0x1e, 0xc8, 0xfe, 0x18,
2233     0x3c, 0x2d, 0x59, 0xe3, 0xf9, 0xdf, 0xff, 0x65,
2234     0x3c, 0x71, 0x26, 0xf0, 0xac, 0xb9, 0xe6, 0x42,
2235     0x11, 0xf4, 0x2b, 0xae, 0x12, 0xaf, 0x46, 0x2b,
2236     0x10, 0x70, 0xbe, 0xf1, 0xab, 0x5e, 0x36, 0x06,
2237     0x87, 0x2c, 0xa1, 0x0d, 0xee, 0x15, 0xb3, 0x24,
2238     0x9b, 0x1a, 0x1b, 0x95, 0x8f, 0x23, 0x13, 0x4c,
2239     0x4b, 0xcc, 0xb7, 0xd0, 0x32, 0x00, 0xbc, 0xe4,
2240     0x20, 0xa2, 0xf8, 0xeb, 0x66, 0xdc, 0xf3, 0x64,
2241     0x4d, 0x14, 0x23, 0xc1, 0xb5, 0x69, 0x90, 0x03,
2242     0xc1, 0x3e, 0xce, 0xf4, 0xbf, 0x38, 0xa3, 0xb6,
2243     0x0e, 0xed, 0xc3, 0x40, 0x33, 0xba, 0xc1, 0x90,
2244     0x27, 0x83, 0xdc, 0x6d, 0x89, 0xe2, 0xe7, 0x74,
2245     0x18, 0x8a, 0x43, 0x9c, 0x7e, 0xbc, 0xc0, 0x67,
2246     0x2d, 0xbd, 0xa4, 0xdd, 0xcf, 0xb2, 0x79, 0x46,
2247     0x13, 0xb0, 0xbe, 0x41, 0x31, 0x5e, 0xf7, 0x78,
2248     0x70, 0x8a, 0x70, 0xee, 0x7d, 0x75, 0x16, 0x5c
2249 };
2250
2251 static const u8 T20[] = {
2252     0x8b, 0x30, 0x7f, 0x6b, 0x33, 0x28, 0x6d, 0x0a,
2253     0xb0, 0x26, 0xa9, 0xed, 0x3f, 0xe1, 0xe8, 0x5f
2254 };
2255
2256 # define TEST_CASE(n)    do {                                    \
2257         u8 out[sizeof(P##n)];                                   \
2258         AES_set_encrypt_key(K##n,sizeof(K##n)*8,&key);          \
2259         CRYPTO_gcm128_init(&ctx,&key,(block128_f)AES_encrypt);  \
2260         CRYPTO_gcm128_setiv(&ctx,IV##n,sizeof(IV##n));          \
2261         memset(out,0,sizeof(out));                              \
2262         if (A##n) CRYPTO_gcm128_aad(&ctx,A##n,sizeof(A##n));    \
2263         if (P##n) CRYPTO_gcm128_encrypt(&ctx,P##n,out,sizeof(out));     \
2264         if (CRYPTO_gcm128_finish(&ctx,T##n,16) ||               \
2265             (C##n && memcmp(out,C##n,sizeof(out))))             \
2266                 ret++, printf ("encrypt test#%d failed.\n",n);  \
2267         CRYPTO_gcm128_setiv(&ctx,IV##n,sizeof(IV##n));          \
2268         memset(out,0,sizeof(out));                              \
2269         if (A##n) CRYPTO_gcm128_aad(&ctx,A##n,sizeof(A##n));    \
2270         if (C##n) CRYPTO_gcm128_decrypt(&ctx,C##n,out,sizeof(out));     \
2271         if (CRYPTO_gcm128_finish(&ctx,T##n,16) ||               \
2272             (P##n && memcmp(out,P##n,sizeof(out))))             \
2273                 ret++, printf ("decrypt test#%d failed.\n",n);  \
2274         } while(0)
2275
2276 int main()
2277 {
2278     GCM128_CONTEXT ctx;
2279     AES_KEY key;
2280     int ret = 0;
2281
2282     TEST_CASE(1);
2283     TEST_CASE(2);
2284     TEST_CASE(3);
2285     TEST_CASE(4);
2286     TEST_CASE(5);
2287     TEST_CASE(6);
2288     TEST_CASE(7);
2289     TEST_CASE(8);
2290     TEST_CASE(9);
2291     TEST_CASE(10);
2292     TEST_CASE(11);
2293     TEST_CASE(12);
2294     TEST_CASE(13);
2295     TEST_CASE(14);
2296     TEST_CASE(15);
2297     TEST_CASE(16);
2298     TEST_CASE(17);
2299     TEST_CASE(18);
2300     TEST_CASE(19);
2301     TEST_CASE(20);
2302
2303 # ifdef OPENSSL_CPUID_OBJ
2304     {
2305         size_t start, stop, gcm_t, ctr_t, OPENSSL_rdtsc();
2306         union {
2307             u64 u;
2308             u8 c[1024];
2309         } buf;
2310         int i;
2311
2312         AES_set_encrypt_key(K1, sizeof(K1) * 8, &key);
2313         CRYPTO_gcm128_init(&ctx, &key, (block128_f) AES_encrypt);
2314         CRYPTO_gcm128_setiv(&ctx, IV1, sizeof(IV1));
2315
2316         CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));
2317         start = OPENSSL_rdtsc();
2318         CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));
2319         gcm_t = OPENSSL_rdtsc() - start;
2320
2321         CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),
2322                               &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,
2323                               (block128_f) AES_encrypt);
2324         start = OPENSSL_rdtsc();
2325         CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),
2326                               &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,
2327                               (block128_f) AES_encrypt);
2328         ctr_t = OPENSSL_rdtsc() - start;
2329
2330         printf("%.2f-%.2f=%.2f\n",
2331                gcm_t / (double)sizeof(buf),
2332                ctr_t / (double)sizeof(buf),
2333                (gcm_t - ctr_t) / (double)sizeof(buf));
2334 #  ifdef GHASH
2335         {
2336             void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
2337                                  const u8 *inp, size_t len) = ctx.ghash;
2338
2339             GHASH((&ctx), buf.c, sizeof(buf));
2340             start = OPENSSL_rdtsc();
2341             for (i = 0; i < 100; ++i)
2342                 GHASH((&ctx), buf.c, sizeof(buf));
2343             gcm_t = OPENSSL_rdtsc() - start;
2344             printf("%.2f\n", gcm_t / (double)sizeof(buf) / (double)i);
2345         }
2346 #  endif
2347     }
2348 # endif
2349
2350     return ret;
2351 }
2352 #endif