crypto/modes/gcm128.c

   1 /*
   2  * Copyright 2010-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <openssl/crypto.h>
  11 #include "modes_lcl.h"
  12 #include <string.h>
  13
  14 #if defined(BSWAP4) && defined(STRICT_ALIGNMENT)
  15 /* redefine, because alignment is ensured */
  16 # undef  GETU32
  17 # define GETU32(p)       BSWAP4(*(const u32 *)(p))
  18 # undef  PUTU32
  19 # define PUTU32(p,v)     *(u32 *)(p) = BSWAP4(v)
  20 #endif
  21
  22 #define PACK(s)         ((size_t)(s)<<(sizeof(size_t)*8-16))
  23 #define REDUCE1BIT(V)   do { \
  24         if (sizeof(size_t)==8) { \
  25                 u64 T = U64(0xe100000000000000) & (0-(V.lo&1)); \
  26                 V.lo  = (V.hi<<63)|(V.lo>>1); \
  27                 V.hi  = (V.hi>>1 )^T; \
  28         } \
  29         else { \
  30                 u32 T = 0xe1000000U & (0-(u32)(V.lo&1)); \
  31                 V.lo  = (V.hi<<63)|(V.lo>>1); \
  32                 V.hi  = (V.hi>>1 )^((u64)T<<32); \
  33         } \
  34 } while(0)
  35
  36 /*-
  37  * Even though permitted values for TABLE_BITS are 8, 4 and 1, it should
  38  * never be set to 8. 8 is effectively reserved for testing purposes.
  39  * TABLE_BITS>1 are lookup-table-driven implementations referred to as
  40  * "Shoup's" in GCM specification. In other words OpenSSL does not cover
  41  * whole spectrum of possible table driven implementations. Why? In
  42  * non-"Shoup's" case memory access pattern is segmented in such manner,
  43  * that it's trivial to see that cache timing information can reveal
  44  * fair portion of intermediate hash value. Given that ciphertext is
  45  * always available to attacker, it's possible for him to attempt to
  46  * deduce secret parameter H and if successful, tamper with messages
  47  * [which is nothing but trivial in CTR mode]. In "Shoup's" case it's
  48  * not as trivial, but there is no reason to believe that it's resistant
  49  * to cache-timing attack. And the thing about "8-bit" implementation is
  50  * that it consumes 16 (sixteen) times more memory, 4KB per individual
  51  * key + 1KB shared. Well, on pros side it should be twice as fast as
  52  * "4-bit" version. And for gcc-generated x86[_64] code, "8-bit" version
  53  * was observed to run ~75% faster, closer to 100% for commercial
  54  * compilers... Yet "4-bit" procedure is preferred, because it's
  55  * believed to provide better security-performance balance and adequate
  56  * all-round performance. "All-round" refers to things like:
  57  *
  58  * - shorter setup time effectively improves overall timing for
  59  *   handling short messages;
  60  * - larger table allocation can become unbearable because of VM
  61  *   subsystem penalties (for example on Windows large enough free
  62  *   results in VM working set trimming, meaning that consequent
  63  *   malloc would immediately incur working set expansion);
  64  * - larger table has larger cache footprint, which can affect
  65  *   performance of other code paths (not necessarily even from same
  66  *   thread in Hyper-Threading world);
  67  *
  68  * Value of 1 is not appropriate for performance reasons.
  69  */
  70 #if     TABLE_BITS==8
  71
  72 static void gcm_init_8bit(u128 Htable[256], u64 H[2])
  73 {
  74     int i, j;
  75     u128 V;
  76
  77     Htable[0].hi = 0;
  78     Htable[0].lo = 0;
  79     V.hi = H[0];
  80     V.lo = H[1];
  81
  82     for (Htable[128] = V, i = 64; i > 0; i >>= 1) {
  83         REDUCE1BIT(V);
  84         Htable[i] = V;
  85     }
  86
  87     for (i = 2; i < 256; i <<= 1) {
  88         u128 *Hi = Htable + i, H0 = *Hi;
  89         for (j = 1; j < i; ++j) {
  90             Hi[j].hi = H0.hi ^ Htable[j].hi;
  91             Hi[j].lo = H0.lo ^ Htable[j].lo;
  92         }
  93     }
  94 }
  95
  96 static void gcm_gmult_8bit(u64 Xi[2], const u128 Htable[256])
  97 {
  98     u128 Z = { 0, 0 };
  99     const u8 *xi = (const u8 *)Xi + 15;
 100     size_t rem, n = *xi;
 101     const union {
 102         long one;
 103         char little;
 104     } is_endian = { 1 };
 105     static const size_t rem_8bit[256] = {
 106         PACK(0x0000), PACK(0x01C2), PACK(0x0384), PACK(0x0246),
 107         PACK(0x0708), PACK(0x06CA), PACK(0x048C), PACK(0x054E),
 108         PACK(0x0E10), PACK(0x0FD2), PACK(0x0D94), PACK(0x0C56),
 109         PACK(0x0918), PACK(0x08DA), PACK(0x0A9C), PACK(0x0B5E),
 110         PACK(0x1C20), PACK(0x1DE2), PACK(0x1FA4), PACK(0x1E66),
 111         PACK(0x1B28), PACK(0x1AEA), PACK(0x18AC), PACK(0x196E),
 112         PACK(0x1230), PACK(0x13F2), PACK(0x11B4), PACK(0x1076),
 113         PACK(0x1538), PACK(0x14FA), PACK(0x16BC), PACK(0x177E),
 114         PACK(0x3840), PACK(0x3982), PACK(0x3BC4), PACK(0x3A06),
 115         PACK(0x3F48), PACK(0x3E8A), PACK(0x3CCC), PACK(0x3D0E),
 116         PACK(0x3650), PACK(0x3792), PACK(0x35D4), PACK(0x3416),
 117         PACK(0x3158), PACK(0x309A), PACK(0x32DC), PACK(0x331E),
 118         PACK(0x2460), PACK(0x25A2), PACK(0x27E4), PACK(0x2626),
 119         PACK(0x2368), PACK(0x22AA), PACK(0x20EC), PACK(0x212E),
 120         PACK(0x2A70), PACK(0x2BB2), PACK(0x29F4), PACK(0x2836),
 121         PACK(0x2D78), PACK(0x2CBA), PACK(0x2EFC), PACK(0x2F3E),
 122         PACK(0x7080), PACK(0x7142), PACK(0x7304), PACK(0x72C6),
 123         PACK(0x7788), PACK(0x764A), PACK(0x740C), PACK(0x75CE),
 124         PACK(0x7E90), PACK(0x7F52), PACK(0x7D14), PACK(0x7CD6),
 125         PACK(0x7998), PACK(0x785A), PACK(0x7A1C), PACK(0x7BDE),
 126         PACK(0x6CA0), PACK(0x6D62), PACK(0x6F24), PACK(0x6EE6),
 127         PACK(0x6BA8), PACK(0x6A6A), PACK(0x682C), PACK(0x69EE),
 128         PACK(0x62B0), PACK(0x6372), PACK(0x6134), PACK(0x60F6),
 129         PACK(0x65B8), PACK(0x647A), PACK(0x663C), PACK(0x67FE),
 130         PACK(0x48C0), PACK(0x4902), PACK(0x4B44), PACK(0x4A86),
 131         PACK(0x4FC8), PACK(0x4E0A), PACK(0x4C4C), PACK(0x4D8E),
 132         PACK(0x46D0), PACK(0x4712), PACK(0x4554), PACK(0x4496),
 133         PACK(0x41D8), PACK(0x401A), PACK(0x425C), PACK(0x439E),
 134         PACK(0x54E0), PACK(0x5522), PACK(0x5764), PACK(0x56A6),
 135         PACK(0x53E8), PACK(0x522A), PACK(0x506C), PACK(0x51AE),
 136         PACK(0x5AF0), PACK(0x5B32), PACK(0x5974), PACK(0x58B6),
 137         PACK(0x5DF8), PACK(0x5C3A), PACK(0x5E7C), PACK(0x5FBE),
 138         PACK(0xE100), PACK(0xE0C2), PACK(0xE284), PACK(0xE346),
 139         PACK(0xE608), PACK(0xE7CA), PACK(0xE58C), PACK(0xE44E),
 140         PACK(0xEF10), PACK(0xEED2), PACK(0xEC94), PACK(0xED56),
 141         PACK(0xE818), PACK(0xE9DA), PACK(0xEB9C), PACK(0xEA5E),
 142         PACK(0xFD20), PACK(0xFCE2), PACK(0xFEA4), PACK(0xFF66),
 143         PACK(0xFA28), PACK(0xFBEA), PACK(0xF9AC), PACK(0xF86E),
 144         PACK(0xF330), PACK(0xF2F2), PACK(0xF0B4), PACK(0xF176),
 145         PACK(0xF438), PACK(0xF5FA), PACK(0xF7BC), PACK(0xF67E),
 146         PACK(0xD940), PACK(0xD882), PACK(0xDAC4), PACK(0xDB06),
 147         PACK(0xDE48), PACK(0xDF8A), PACK(0xDDCC), PACK(0xDC0E),
 148         PACK(0xD750), PACK(0xD692), PACK(0xD4D4), PACK(0xD516),
 149         PACK(0xD058), PACK(0xD19A), PACK(0xD3DC), PACK(0xD21E),
 150         PACK(0xC560), PACK(0xC4A2), PACK(0xC6E4), PACK(0xC726),
 151         PACK(0xC268), PACK(0xC3AA), PACK(0xC1EC), PACK(0xC02E),
 152         PACK(0xCB70), PACK(0xCAB2), PACK(0xC8F4), PACK(0xC936),
 153         PACK(0xCC78), PACK(0xCDBA), PACK(0xCFFC), PACK(0xCE3E),
 154         PACK(0x9180), PACK(0x9042), PACK(0x9204), PACK(0x93C6),
 155         PACK(0x9688), PACK(0x974A), PACK(0x950C), PACK(0x94CE),
 156         PACK(0x9F90), PACK(0x9E52), PACK(0x9C14), PACK(0x9DD6),
 157         PACK(0x9898), PACK(0x995A), PACK(0x9B1C), PACK(0x9ADE),
 158         PACK(0x8DA0), PACK(0x8C62), PACK(0x8E24), PACK(0x8FE6),
 159         PACK(0x8AA8), PACK(0x8B6A), PACK(0x892C), PACK(0x88EE),
 160         PACK(0x83B0), PACK(0x8272), PACK(0x8034), PACK(0x81F6),
 161         PACK(0x84B8), PACK(0x857A), PACK(0x873C), PACK(0x86FE),
 162         PACK(0xA9C0), PACK(0xA802), PACK(0xAA44), PACK(0xAB86),
 163         PACK(0xAEC8), PACK(0xAF0A), PACK(0xAD4C), PACK(0xAC8E),
 164         PACK(0xA7D0), PACK(0xA612), PACK(0xA454), PACK(0xA596),
 165         PACK(0xA0D8), PACK(0xA11A), PACK(0xA35C), PACK(0xA29E),
 166         PACK(0xB5E0), PACK(0xB422), PACK(0xB664), PACK(0xB7A6),
 167         PACK(0xB2E8), PACK(0xB32A), PACK(0xB16C), PACK(0xB0AE),
 168         PACK(0xBBF0), PACK(0xBA32), PACK(0xB874), PACK(0xB9B6),
 169         PACK(0xBCF8), PACK(0xBD3A), PACK(0xBF7C), PACK(0xBEBE)
 170     };
 171
 172     while (1) {
 173         Z.hi ^= Htable[n].hi;
 174         Z.lo ^= Htable[n].lo;
 175
 176         if ((u8 *)Xi == xi)
 177             break;
 178
 179         n = *(--xi);
 180
 181         rem = (size_t)Z.lo & 0xff;
 182         Z.lo = (Z.hi << 56) | (Z.lo >> 8);
 183         Z.hi = (Z.hi >> 8);
 184         if (sizeof(size_t) == 8)
 185             Z.hi ^= rem_8bit[rem];
 186         else
 187             Z.hi ^= (u64)rem_8bit[rem] << 32;
 188     }
 189
 190     if (is_endian.little) {
 191 # ifdef BSWAP8
 192         Xi[0] = BSWAP8(Z.hi);
 193         Xi[1] = BSWAP8(Z.lo);
 194 # else
 195         u8 *p = (u8 *)Xi;
 196         u32 v;
 197         v = (u32)(Z.hi >> 32);
 198         PUTU32(p, v);
 199         v = (u32)(Z.hi);
 200         PUTU32(p + 4, v);
 201         v = (u32)(Z.lo >> 32);
 202         PUTU32(p + 8, v);
 203         v = (u32)(Z.lo);
 204         PUTU32(p + 12, v);
 205 # endif
 206     } else {
 207         Xi[0] = Z.hi;
 208         Xi[1] = Z.lo;
 209     }
 210 }
 211
 212 # define GCM_MUL(ctx)      gcm_gmult_8bit(ctx->Xi.u,ctx->Htable)
 213
 214 #elif   TABLE_BITS==4
 215
 216 static void gcm_init_4bit(u128 Htable[16], u64 H[2])
 217 {
 218     u128 V;
 219 # if defined(OPENSSL_SMALL_FOOTPRINT)
 220     int i;
 221 # endif
 222
 223     Htable[0].hi = 0;
 224     Htable[0].lo = 0;
 225     V.hi = H[0];
 226     V.lo = H[1];
 227
 228 # if defined(OPENSSL_SMALL_FOOTPRINT)
 229     for (Htable[8] = V, i = 4; i > 0; i >>= 1) {
 230         REDUCE1BIT(V);
 231         Htable[i] = V;
 232     }
 233
 234     for (i = 2; i < 16; i <<= 1) {
 235         u128 *Hi = Htable + i;
 236         int j;
 237         for (V = *Hi, j = 1; j < i; ++j) {
 238             Hi[j].hi = V.hi ^ Htable[j].hi;
 239             Hi[j].lo = V.lo ^ Htable[j].lo;
 240         }
 241     }
 242 # else
 243     Htable[8] = V;
 244     REDUCE1BIT(V);
 245     Htable[4] = V;
 246     REDUCE1BIT(V);
 247     Htable[2] = V;
 248     REDUCE1BIT(V);
 249     Htable[1] = V;
 250     Htable[3].hi = V.hi ^ Htable[2].hi, Htable[3].lo = V.lo ^ Htable[2].lo;
 251     V = Htable[4];
 252     Htable[5].hi = V.hi ^ Htable[1].hi, Htable[5].lo = V.lo ^ Htable[1].lo;
 253     Htable[6].hi = V.hi ^ Htable[2].hi, Htable[6].lo = V.lo ^ Htable[2].lo;
 254     Htable[7].hi = V.hi ^ Htable[3].hi, Htable[7].lo = V.lo ^ Htable[3].lo;
 255     V = Htable[8];
 256     Htable[9].hi = V.hi ^ Htable[1].hi, Htable[9].lo = V.lo ^ Htable[1].lo;
 257     Htable[10].hi = V.hi ^ Htable[2].hi, Htable[10].lo = V.lo ^ Htable[2].lo;
 258     Htable[11].hi = V.hi ^ Htable[3].hi, Htable[11].lo = V.lo ^ Htable[3].lo;
 259     Htable[12].hi = V.hi ^ Htable[4].hi, Htable[12].lo = V.lo ^ Htable[4].lo;
 260     Htable[13].hi = V.hi ^ Htable[5].hi, Htable[13].lo = V.lo ^ Htable[5].lo;
 261     Htable[14].hi = V.hi ^ Htable[6].hi, Htable[14].lo = V.lo ^ Htable[6].lo;
 262     Htable[15].hi = V.hi ^ Htable[7].hi, Htable[15].lo = V.lo ^ Htable[7].lo;
 263 # endif
 264 # if defined(GHASH_ASM) && (defined(__arm__) || defined(__arm))
 265     /*
 266      * ARM assembler expects specific dword order in Htable.
 267      */
 268     {
 269         int j;
 270         const union {
 271             long one;
 272             char little;
 273         } is_endian = { 1 };
 274
 275         if (is_endian.little)
 276             for (j = 0; j < 16; ++j) {
 277                 V = Htable[j];
 278                 Htable[j].hi = V.lo;
 279                 Htable[j].lo = V.hi;
 280         } else
 281             for (j = 0; j < 16; ++j) {
 282                 V = Htable[j];
 283                 Htable[j].hi = V.lo << 32 | V.lo >> 32;
 284                 Htable[j].lo = V.hi << 32 | V.hi >> 32;
 285             }
 286     }
 287 # endif
 288 }
 289
 290 # ifndef GHASH_ASM
 291 static const size_t rem_4bit[16] = {
 292     PACK(0x0000), PACK(0x1C20), PACK(0x3840), PACK(0x2460),
 293     PACK(0x7080), PACK(0x6CA0), PACK(0x48C0), PACK(0x54E0),
 294     PACK(0xE100), PACK(0xFD20), PACK(0xD940), PACK(0xC560),
 295     PACK(0x9180), PACK(0x8DA0), PACK(0xA9C0), PACK(0xB5E0)
 296 };
 297
 298 static void gcm_gmult_4bit(u64 Xi[2], const u128 Htable[16])
 299 {
 300     u128 Z;
 301     int cnt = 15;
 302     size_t rem, nlo, nhi;
 303     const union {
 304         long one;
 305         char little;
 306     } is_endian = { 1 };
 307
 308     nlo = ((const u8 *)Xi)[15];
 309     nhi = nlo >> 4;
 310     nlo &= 0xf;
 311
 312     Z.hi = Htable[nlo].hi;
 313     Z.lo = Htable[nlo].lo;
 314
 315     while (1) {
 316         rem = (size_t)Z.lo & 0xf;
 317         Z.lo = (Z.hi << 60) | (Z.lo >> 4);
 318         Z.hi = (Z.hi >> 4);
 319         if (sizeof(size_t) == 8)
 320             Z.hi ^= rem_4bit[rem];
 321         else
 322             Z.hi ^= (u64)rem_4bit[rem] << 32;
 323
 324         Z.hi ^= Htable[nhi].hi;
 325         Z.lo ^= Htable[nhi].lo;
 326
 327         if (--cnt < 0)
 328             break;
 329
 330         nlo = ((const u8 *)Xi)[cnt];
 331         nhi = nlo >> 4;
 332         nlo &= 0xf;
 333
 334         rem = (size_t)Z.lo & 0xf;
 335         Z.lo = (Z.hi << 60) | (Z.lo >> 4);
 336         Z.hi = (Z.hi >> 4);
 337         if (sizeof(size_t) == 8)
 338             Z.hi ^= rem_4bit[rem];
 339         else
 340             Z.hi ^= (u64)rem_4bit[rem] << 32;
 341
 342         Z.hi ^= Htable[nlo].hi;
 343         Z.lo ^= Htable[nlo].lo;
 344     }
 345
 346     if (is_endian.little) {
 347 #  ifdef BSWAP8
 348         Xi[0] = BSWAP8(Z.hi);
 349         Xi[1] = BSWAP8(Z.lo);
 350 #  else
 351         u8 *p = (u8 *)Xi;
 352         u32 v;
 353         v = (u32)(Z.hi >> 32);
 354         PUTU32(p, v);
 355         v = (u32)(Z.hi);
 356         PUTU32(p + 4, v);
 357         v = (u32)(Z.lo >> 32);
 358         PUTU32(p + 8, v);
 359         v = (u32)(Z.lo);
 360         PUTU32(p + 12, v);
 361 #  endif
 362     } else {
 363         Xi[0] = Z.hi;
 364         Xi[1] = Z.lo;
 365     }
 366 }
 367
 368 #  if !defined(OPENSSL_SMALL_FOOTPRINT)
 369 /*
 370  * Streamed gcm_mult_4bit, see CRYPTO_gcm128_[en|de]crypt for
 371  * details... Compiler-generated code doesn't seem to give any
 372  * performance improvement, at least not on x86[_64]. It's here
 373  * mostly as reference and a placeholder for possible future
 374  * non-trivial optimization[s]...
 375  */
 376 static void gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16],
 377                            const u8 *inp, size_t len)
 378 {
 379     u128 Z;
 380     int cnt;
 381     size_t rem, nlo, nhi;
 382     const union {
 383         long one;
 384         char little;
 385     } is_endian = { 1 };
 386
 387 #   if 1
 388     do {
 389         cnt = 15;
 390         nlo = ((const u8 *)Xi)[15];
 391         nlo ^= inp[15];
 392         nhi = nlo >> 4;
 393         nlo &= 0xf;
 394
 395         Z.hi = Htable[nlo].hi;
 396         Z.lo = Htable[nlo].lo;
 397
 398         while (1) {
 399             rem = (size_t)Z.lo & 0xf;
 400             Z.lo = (Z.hi << 60) | (Z.lo >> 4);
 401             Z.hi = (Z.hi >> 4);
 402             if (sizeof(size_t) == 8)
 403                 Z.hi ^= rem_4bit[rem];
 404             else
 405                 Z.hi ^= (u64)rem_4bit[rem] << 32;
 406
 407             Z.hi ^= Htable[nhi].hi;
 408             Z.lo ^= Htable[nhi].lo;
 409
 410             if (--cnt < 0)
 411                 break;
 412
 413             nlo = ((const u8 *)Xi)[cnt];
 414             nlo ^= inp[cnt];
 415             nhi = nlo >> 4;
 416             nlo &= 0xf;
 417
 418             rem = (size_t)Z.lo & 0xf;
 419             Z.lo = (Z.hi << 60) | (Z.lo >> 4);
 420             Z.hi = (Z.hi >> 4);
 421             if (sizeof(size_t) == 8)
 422                 Z.hi ^= rem_4bit[rem];
 423             else
 424                 Z.hi ^= (u64)rem_4bit[rem] << 32;
 425
 426             Z.hi ^= Htable[nlo].hi;
 427             Z.lo ^= Htable[nlo].lo;
 428         }
 429 #   else
 430     /*
 431      * Extra 256+16 bytes per-key plus 512 bytes shared tables
 432      * [should] give ~50% improvement... One could have PACK()-ed
 433      * the rem_8bit even here, but the priority is to minimize
 434      * cache footprint...
 435      */
 436     u128 Hshr4[16];             /* Htable shifted right by 4 bits */
 437     u8 Hshl4[16];               /* Htable shifted left by 4 bits */
 438     static const unsigned short rem_8bit[256] = {
 439         0x0000, 0x01C2, 0x0384, 0x0246, 0x0708, 0x06CA, 0x048C, 0x054E,
 440         0x0E10, 0x0FD2, 0x0D94, 0x0C56, 0x0918, 0x08DA, 0x0A9C, 0x0B5E,
 441         0x1C20, 0x1DE2, 0x1FA4, 0x1E66, 0x1B28, 0x1AEA, 0x18AC, 0x196E,
 442         0x1230, 0x13F2, 0x11B4, 0x1076, 0x1538, 0x14FA, 0x16BC, 0x177E,
 443         0x3840, 0x3982, 0x3BC4, 0x3A06, 0x3F48, 0x3E8A, 0x3CCC, 0x3D0E,
 444         0x3650, 0x3792, 0x35D4, 0x3416, 0x3158, 0x309A, 0x32DC, 0x331E,
 445         0x2460, 0x25A2, 0x27E4, 0x2626, 0x2368, 0x22AA, 0x20EC, 0x212E,
 446         0x2A70, 0x2BB2, 0x29F4, 0x2836, 0x2D78, 0x2CBA, 0x2EFC, 0x2F3E,
 447         0x7080, 0x7142, 0x7304, 0x72C6, 0x7788, 0x764A, 0x740C, 0x75CE,
 448         0x7E90, 0x7F52, 0x7D14, 0x7CD6, 0x7998, 0x785A, 0x7A1C, 0x7BDE,
 449         0x6CA0, 0x6D62, 0x6F24, 0x6EE6, 0x6BA8, 0x6A6A, 0x682C, 0x69EE,
 450         0x62B0, 0x6372, 0x6134, 0x60F6, 0x65B8, 0x647A, 0x663C, 0x67FE,
 451         0x48C0, 0x4902, 0x4B44, 0x4A86, 0x4FC8, 0x4E0A, 0x4C4C, 0x4D8E,
 452         0x46D0, 0x4712, 0x4554, 0x4496, 0x41D8, 0x401A, 0x425C, 0x439E,
 453         0x54E0, 0x5522, 0x5764, 0x56A6, 0x53E8, 0x522A, 0x506C, 0x51AE,
 454         0x5AF0, 0x5B32, 0x5974, 0x58B6, 0x5DF8, 0x5C3A, 0x5E7C, 0x5FBE,
 455         0xE100, 0xE0C2, 0xE284, 0xE346, 0xE608, 0xE7CA, 0xE58C, 0xE44E,
 456         0xEF10, 0xEED2, 0xEC94, 0xED56, 0xE818, 0xE9DA, 0xEB9C, 0xEA5E,
 457         0xFD20, 0xFCE2, 0xFEA4, 0xFF66, 0xFA28, 0xFBEA, 0xF9AC, 0xF86E,
 458         0xF330, 0xF2F2, 0xF0B4, 0xF176, 0xF438, 0xF5FA, 0xF7BC, 0xF67E,
 459         0xD940, 0xD882, 0xDAC4, 0xDB06, 0xDE48, 0xDF8A, 0xDDCC, 0xDC0E,
 460         0xD750, 0xD692, 0xD4D4, 0xD516, 0xD058, 0xD19A, 0xD3DC, 0xD21E,
 461         0xC560, 0xC4A2, 0xC6E4, 0xC726, 0xC268, 0xC3AA, 0xC1EC, 0xC02E,
 462         0xCB70, 0xCAB2, 0xC8F4, 0xC936, 0xCC78, 0xCDBA, 0xCFFC, 0xCE3E,
 463         0x9180, 0x9042, 0x9204, 0x93C6, 0x9688, 0x974A, 0x950C, 0x94CE,
 464         0x9F90, 0x9E52, 0x9C14, 0x9DD6, 0x9898, 0x995A, 0x9B1C, 0x9ADE,
 465         0x8DA0, 0x8C62, 0x8E24, 0x8FE6, 0x8AA8, 0x8B6A, 0x892C, 0x88EE,
 466         0x83B0, 0x8272, 0x8034, 0x81F6, 0x84B8, 0x857A, 0x873C, 0x86FE,
 467         0xA9C0, 0xA802, 0xAA44, 0xAB86, 0xAEC8, 0xAF0A, 0xAD4C, 0xAC8E,
 468         0xA7D0, 0xA612, 0xA454, 0xA596, 0xA0D8, 0xA11A, 0xA35C, 0xA29E,
 469         0xB5E0, 0xB422, 0xB664, 0xB7A6, 0xB2E8, 0xB32A, 0xB16C, 0xB0AE,
 470         0xBBF0, 0xBA32, 0xB874, 0xB9B6, 0xBCF8, 0xBD3A, 0xBF7C, 0xBEBE
 471     };
 472     /*
 473      * This pre-processing phase slows down procedure by approximately
 474      * same time as it makes each loop spin faster. In other words
 475      * single block performance is approximately same as straightforward
 476      * "4-bit" implementation, and then it goes only faster...
 477      */
 478     for (cnt = 0; cnt < 16; ++cnt) {
 479         Z.hi = Htable[cnt].hi;
 480         Z.lo = Htable[cnt].lo;
 481         Hshr4[cnt].lo = (Z.hi << 60) | (Z.lo >> 4);
 482         Hshr4[cnt].hi = (Z.hi >> 4);
 483         Hshl4[cnt] = (u8)(Z.lo << 4);
 484     }
 485
 486     do {
 487         for (Z.lo = 0, Z.hi = 0, cnt = 15; cnt; --cnt) {
 488             nlo = ((const u8 *)Xi)[cnt];
 489             nlo ^= inp[cnt];
 490             nhi = nlo >> 4;
 491             nlo &= 0xf;
 492
 493             Z.hi ^= Htable[nlo].hi;
 494             Z.lo ^= Htable[nlo].lo;
 495
 496             rem = (size_t)Z.lo & 0xff;
 497
 498             Z.lo = (Z.hi << 56) | (Z.lo >> 8);
 499             Z.hi = (Z.hi >> 8);
 500
 501             Z.hi ^= Hshr4[nhi].hi;
 502             Z.lo ^= Hshr4[nhi].lo;
 503             Z.hi ^= (u64)rem_8bit[rem ^ Hshl4[nhi]] << 48;
 504         }
 505
 506         nlo = ((const u8 *)Xi)[0];
 507         nlo ^= inp[0];
 508         nhi = nlo >> 4;
 509         nlo &= 0xf;
 510
 511         Z.hi ^= Htable[nlo].hi;
 512         Z.lo ^= Htable[nlo].lo;
 513
 514         rem = (size_t)Z.lo & 0xf;
 515
 516         Z.lo = (Z.hi << 60) | (Z.lo >> 4);
 517         Z.hi = (Z.hi >> 4);
 518
 519         Z.hi ^= Htable[nhi].hi;
 520         Z.lo ^= Htable[nhi].lo;
 521         Z.hi ^= ((u64)rem_8bit[rem << 4]) << 48;
 522 #   endif
 523
 524         if (is_endian.little) {
 525 #   ifdef BSWAP8
 526             Xi[0] = BSWAP8(Z.hi);
 527             Xi[1] = BSWAP8(Z.lo);
 528 #   else
 529             u8 *p = (u8 *)Xi;
 530             u32 v;
 531             v = (u32)(Z.hi >> 32);
 532             PUTU32(p, v);
 533             v = (u32)(Z.hi);
 534             PUTU32(p + 4, v);
 535             v = (u32)(Z.lo >> 32);
 536             PUTU32(p + 8, v);
 537             v = (u32)(Z.lo);
 538             PUTU32(p + 12, v);
 539 #   endif
 540         } else {
 541             Xi[0] = Z.hi;
 542             Xi[1] = Z.lo;
 543         }
 544     } while (inp += 16, len -= 16);
 545 }
 546 #  endif
 547 # else
 548 void gcm_gmult_4bit(u64 Xi[2], const u128 Htable[16]);
 549 void gcm_ghash_4bit(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 550                     size_t len);
 551 # endif
 552
 553 # define GCM_MUL(ctx)      gcm_gmult_4bit(ctx->Xi.u,ctx->Htable)
 554 # if defined(GHASH_ASM) || !defined(OPENSSL_SMALL_FOOTPRINT)
 555 #  define GHASH(ctx,in,len) gcm_ghash_4bit((ctx)->Xi.u,(ctx)->Htable,in,len)
 556 /*
 557  * GHASH_CHUNK is "stride parameter" missioned to mitigate cache trashing
 558  * effect. In other words idea is to hash data while it's still in L1 cache
 559  * after encryption pass...
 560  */
 561 #  define GHASH_CHUNK       (3*1024)
 562 # endif
 563
 564 #else                           /* TABLE_BITS */
 565
 566 static void gcm_gmult_1bit(u64 Xi[2], const u64 H[2])
 567 {
 568     u128 V, Z = { 0, 0 };
 569     long X;
 570     int i, j;
 571     const long *xi = (const long *)Xi;
 572     const union {
 573         long one;
 574         char little;
 575     } is_endian = { 1 };
 576
 577     V.hi = H[0];                /* H is in host byte order, no byte swapping */
 578     V.lo = H[1];
 579
 580     for (j = 0; j < 16 / sizeof(long); ++j) {
 581         if (is_endian.little) {
 582             if (sizeof(long) == 8) {
 583 # ifdef BSWAP8
 584                 X = (long)(BSWAP8(xi[j]));
 585 # else
 586                 const u8 *p = (const u8 *)(xi + j);
 587                 X = (long)((u64)GETU32(p) << 32 | GETU32(p + 4));
 588 # endif
 589             } else {
 590                 const u8 *p = (const u8 *)(xi + j);
 591                 X = (long)GETU32(p);
 592             }
 593         } else
 594             X = xi[j];
 595
 596         for (i = 0; i < 8 * sizeof(long); ++i, X <<= 1) {
 597             u64 M = (u64)(X >> (8 * sizeof(long) - 1));
 598             Z.hi ^= V.hi & M;
 599             Z.lo ^= V.lo & M;
 600
 601             REDUCE1BIT(V);
 602         }
 603     }
 604
 605     if (is_endian.little) {
 606 # ifdef BSWAP8
 607         Xi[0] = BSWAP8(Z.hi);
 608         Xi[1] = BSWAP8(Z.lo);
 609 # else
 610         u8 *p = (u8 *)Xi;
 611         u32 v;
 612         v = (u32)(Z.hi >> 32);
 613         PUTU32(p, v);
 614         v = (u32)(Z.hi);
 615         PUTU32(p + 4, v);
 616         v = (u32)(Z.lo >> 32);
 617         PUTU32(p + 8, v);
 618         v = (u32)(Z.lo);
 619         PUTU32(p + 12, v);
 620 # endif
 621     } else {
 622         Xi[0] = Z.hi;
 623         Xi[1] = Z.lo;
 624     }
 625 }
 626
 627 # define GCM_MUL(ctx)      gcm_gmult_1bit(ctx->Xi.u,ctx->H.u)
 628
 629 #endif
 630
 631 #if     TABLE_BITS==4 && (defined(GHASH_ASM) || defined(OPENSSL_CPUID_OBJ))
 632 # if    !defined(I386_ONLY) && \
 633         (defined(__i386)        || defined(__i386__)    || \
 634          defined(__x86_64)      || defined(__x86_64__)  || \
 635          defined(_M_IX86)       || defined(_M_AMD64)    || defined(_M_X64))
 636 #  define GHASH_ASM_X86_OR_64
 637 #  define GCM_FUNCREF_4BIT
 638 extern unsigned int OPENSSL_ia32cap_P[];
 639
 640 void gcm_init_clmul(u128 Htable[16], const u64 Xi[2]);
 641 void gcm_gmult_clmul(u64 Xi[2], const u128 Htable[16]);
 642 void gcm_ghash_clmul(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 643                      size_t len);
 644
 645 #  if defined(__i386) || defined(__i386__) || defined(_M_IX86)
 646 #   define gcm_init_avx   gcm_init_clmul
 647 #   define gcm_gmult_avx  gcm_gmult_clmul
 648 #   define gcm_ghash_avx  gcm_ghash_clmul
 649 #  else
 650 void gcm_init_avx(u128 Htable[16], const u64 Xi[2]);
 651 void gcm_gmult_avx(u64 Xi[2], const u128 Htable[16]);
 652 void gcm_ghash_avx(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 653                    size_t len);
 654 #  endif
 655
 656 #  if   defined(__i386) || defined(__i386__) || defined(_M_IX86)
 657 #   define GHASH_ASM_X86
 658 void gcm_gmult_4bit_mmx(u64 Xi[2], const u128 Htable[16]);
 659 void gcm_ghash_4bit_mmx(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 660                         size_t len);
 661
 662 void gcm_gmult_4bit_x86(u64 Xi[2], const u128 Htable[16]);
 663 void gcm_ghash_4bit_x86(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 664                         size_t len);
 665 #  endif
 666 # elif defined(__arm__) || defined(__arm) || defined(__aarch64__)
 667 #  include "arm_arch.h"
 668 #  if __ARM_MAX_ARCH__>=7
 669 #   define GHASH_ASM_ARM
 670 #   define GCM_FUNCREF_4BIT
 671 #   define PMULL_CAPABLE        (OPENSSL_armcap_P & ARMV8_PMULL)
 672 #   if defined(__arm__) || defined(__arm)
 673 #    define NEON_CAPABLE        (OPENSSL_armcap_P & ARMV7_NEON)
 674 #   endif
 675 void gcm_init_neon(u128 Htable[16], const u64 Xi[2]);
 676 void gcm_gmult_neon(u64 Xi[2], const u128 Htable[16]);
 677 void gcm_ghash_neon(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 678                     size_t len);
 679 void gcm_init_v8(u128 Htable[16], const u64 Xi[2]);
 680 void gcm_gmult_v8(u64 Xi[2], const u128 Htable[16]);
 681 void gcm_ghash_v8(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 682                   size_t len);
 683 #  endif
 684 # elif defined(__sparc__) || defined(__sparc)
 685 #  include "sparc_arch.h"
 686 #  define GHASH_ASM_SPARC
 687 #  define GCM_FUNCREF_4BIT
 688 extern unsigned int OPENSSL_sparcv9cap_P[];
 689 void gcm_init_vis3(u128 Htable[16], const u64 Xi[2]);
 690 void gcm_gmult_vis3(u64 Xi[2], const u128 Htable[16]);
 691 void gcm_ghash_vis3(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 692                     size_t len);
 693 # elif defined(OPENSSL_CPUID_OBJ) && (defined(__powerpc__) || defined(__ppc__) || defined(_ARCH_PPC))
 694 #  include "ppc_arch.h"
 695 #  define GHASH_ASM_PPC
 696 #  define GCM_FUNCREF_4BIT
 697 void gcm_init_p8(u128 Htable[16], const u64 Xi[2]);
 698 void gcm_gmult_p8(u64 Xi[2], const u128 Htable[16]);
 699 void gcm_ghash_p8(u64 Xi[2], const u128 Htable[16], const u8 *inp,
 700                   size_t len);
 701 # endif
 702 #endif
 703
 704 #ifdef GCM_FUNCREF_4BIT
 705 # undef  GCM_MUL
 706 # define GCM_MUL(ctx)           (*gcm_gmult_p)(ctx->Xi.u,ctx->Htable)
 707 # ifdef GHASH
 708 #  undef  GHASH
 709 #  define GHASH(ctx,in,len)     (*gcm_ghash_p)(ctx->Xi.u,ctx->Htable,in,len)
 710 # endif
 711 #endif
 712
 713 void CRYPTO_gcm128_init(GCM128_CONTEXT *ctx, void *key, block128_f block)
 714 {
 715     const union {
 716         long one;
 717         char little;
 718     } is_endian = { 1 };
 719
 720     memset(ctx, 0, sizeof(*ctx));
 721     ctx->block = block;
 722     ctx->key = key;
 723
 724     (*block) (ctx->H.c, ctx->H.c, key);
 725
 726     if (is_endian.little) {
 727         /* H is stored in host byte order */
 728 #ifdef BSWAP8
 729         ctx->H.u[0] = BSWAP8(ctx->H.u[0]);
 730         ctx->H.u[1] = BSWAP8(ctx->H.u[1]);
 731 #else
 732         u8 *p = ctx->H.c;
 733         u64 hi, lo;
 734         hi = (u64)GETU32(p) << 32 | GETU32(p + 4);
 735         lo = (u64)GETU32(p + 8) << 32 | GETU32(p + 12);
 736         ctx->H.u[0] = hi;
 737         ctx->H.u[1] = lo;
 738 #endif
 739     }
 740 #if     TABLE_BITS==8
 741     gcm_init_8bit(ctx->Htable, ctx->H.u);
 742 #elif   TABLE_BITS==4
 743 # if    defined(GHASH)
 744 #  define CTX__GHASH(f) (ctx->ghash = (f))
 745 # else
 746 #  define CTX__GHASH(f) (ctx->ghash = NULL)
 747 # endif
 748 # if    defined(GHASH_ASM_X86_OR_64)
 749 #  if   !defined(GHASH_ASM_X86) || defined(OPENSSL_IA32_SSE2)
 750     if (OPENSSL_ia32cap_P[1] & (1 << 1)) { /* check PCLMULQDQ bit */
 751         if (((OPENSSL_ia32cap_P[1] >> 22) & 0x41) == 0x41) { /* AVX+MOVBE */
 752             gcm_init_avx(ctx->Htable, ctx->H.u);
 753             ctx->gmult = gcm_gmult_avx;
 754             CTX__GHASH(gcm_ghash_avx);
 755         } else {
 756             gcm_init_clmul(ctx->Htable, ctx->H.u);
 757             ctx->gmult = gcm_gmult_clmul;
 758             CTX__GHASH(gcm_ghash_clmul);
 759         }
 760         return;
 761     }
 762 #  endif
 763     gcm_init_4bit(ctx->Htable, ctx->H.u);
 764 #  if   defined(GHASH_ASM_X86)  /* x86 only */
 765 #   if  defined(OPENSSL_IA32_SSE2)
 766     if (OPENSSL_ia32cap_P[0] & (1 << 25)) { /* check SSE bit */
 767 #   else
 768     if (OPENSSL_ia32cap_P[0] & (1 << 23)) { /* check MMX bit */
 769 #   endif
 770         ctx->gmult = gcm_gmult_4bit_mmx;
 771         CTX__GHASH(gcm_ghash_4bit_mmx);
 772     } else {
 773         ctx->gmult = gcm_gmult_4bit_x86;
 774         CTX__GHASH(gcm_ghash_4bit_x86);
 775     }
 776 #  else
 777     ctx->gmult = gcm_gmult_4bit;
 778     CTX__GHASH(gcm_ghash_4bit);
 779 #  endif
 780 # elif  defined(GHASH_ASM_ARM)
 781 #  ifdef PMULL_CAPABLE
 782     if (PMULL_CAPABLE) {
 783         gcm_init_v8(ctx->Htable, ctx->H.u);
 784         ctx->gmult = gcm_gmult_v8;
 785         CTX__GHASH(gcm_ghash_v8);
 786     } else
 787 #  endif
 788 #  ifdef NEON_CAPABLE
 789     if (NEON_CAPABLE) {
 790         gcm_init_neon(ctx->Htable, ctx->H.u);
 791         ctx->gmult = gcm_gmult_neon;
 792         CTX__GHASH(gcm_ghash_neon);
 793     } else
 794 #  endif
 795     {
 796         gcm_init_4bit(ctx->Htable, ctx->H.u);
 797         ctx->gmult = gcm_gmult_4bit;
 798         CTX__GHASH(gcm_ghash_4bit);
 799     }
 800 # elif  defined(GHASH_ASM_SPARC)
 801     if (OPENSSL_sparcv9cap_P[0] & SPARCV9_VIS3) {
 802         gcm_init_vis3(ctx->Htable, ctx->H.u);
 803         ctx->gmult = gcm_gmult_vis3;
 804         CTX__GHASH(gcm_ghash_vis3);
 805     } else {
 806         gcm_init_4bit(ctx->Htable, ctx->H.u);
 807         ctx->gmult = gcm_gmult_4bit;
 808         CTX__GHASH(gcm_ghash_4bit);
 809     }
 810 # elif  defined(GHASH_ASM_PPC)
 811     if (OPENSSL_ppccap_P & PPC_CRYPTO207) {
 812         gcm_init_p8(ctx->Htable, ctx->H.u);
 813         ctx->gmult = gcm_gmult_p8;
 814         CTX__GHASH(gcm_ghash_p8);
 815     } else {
 816         gcm_init_4bit(ctx->Htable, ctx->H.u);
 817         ctx->gmult = gcm_gmult_4bit;
 818         CTX__GHASH(gcm_ghash_4bit);
 819     }
 820 # else
 821     gcm_init_4bit(ctx->Htable, ctx->H.u);
 822 # endif
 823 # undef CTX__GHASH
 824 #endif
 825 }
 826
 827 void CRYPTO_gcm128_setiv(GCM128_CONTEXT *ctx, const unsigned char *iv,
 828                          size_t len)
 829 {
 830     const union {
 831         long one;
 832         char little;
 833     } is_endian = { 1 };
 834     unsigned int ctr;
 835 #ifdef GCM_FUNCREF_4BIT
 836     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
 837 #endif
 838
 839     ctx->len.u[0] = 0;          /* AAD length */
 840     ctx->len.u[1] = 0;          /* message length */
 841     ctx->ares = 0;
 842     ctx->mres = 0;
 843
 844     if (len == 12) {
 845         memcpy(ctx->Yi.c, iv, 12);
 846         ctx->Yi.c[12] = 0;
 847         ctx->Yi.c[13] = 0;
 848         ctx->Yi.c[14] = 0;
 849         ctx->Yi.c[15] = 1;
 850         ctr = 1;
 851     } else {
 852         size_t i;
 853         u64 len0 = len;
 854
 855         /* Borrow ctx->Xi to calculate initial Yi */
 856         ctx->Xi.u[0] = 0;
 857         ctx->Xi.u[1] = 0;
 858
 859         while (len >= 16) {
 860             for (i = 0; i < 16; ++i)
 861                 ctx->Xi.c[i] ^= iv[i];
 862             GCM_MUL(ctx);
 863             iv += 16;
 864             len -= 16;
 865         }
 866         if (len) {
 867             for (i = 0; i < len; ++i)
 868                 ctx->Xi.c[i] ^= iv[i];
 869             GCM_MUL(ctx);
 870         }
 871         len0 <<= 3;
 872         if (is_endian.little) {
 873 #ifdef BSWAP8
 874             ctx->Xi.u[1] ^= BSWAP8(len0);
 875 #else
 876             ctx->Xi.c[8] ^= (u8)(len0 >> 56);
 877             ctx->Xi.c[9] ^= (u8)(len0 >> 48);
 878             ctx->Xi.c[10] ^= (u8)(len0 >> 40);
 879             ctx->Xi.c[11] ^= (u8)(len0 >> 32);
 880             ctx->Xi.c[12] ^= (u8)(len0 >> 24);
 881             ctx->Xi.c[13] ^= (u8)(len0 >> 16);
 882             ctx->Xi.c[14] ^= (u8)(len0 >> 8);
 883             ctx->Xi.c[15] ^= (u8)(len0);
 884 #endif
 885         } else {
 886             ctx->Xi.u[1] ^= len0;
 887         }
 888
 889         GCM_MUL(ctx);
 890
 891         if (is_endian.little)
 892 #ifdef BSWAP4
 893             ctr = BSWAP4(ctx->Xi.d[3]);
 894 #else
 895             ctr = GETU32(ctx->Xi.c + 12);
 896 #endif
 897         else
 898             ctr = ctx->Xi.d[3];
 899
 900         /* Copy borrowed Xi to Yi */
 901         ctx->Yi.u[0] = ctx->Xi.u[0];
 902         ctx->Yi.u[1] = ctx->Xi.u[1];
 903     }
 904
 905     ctx->Xi.u[0] = 0;
 906     ctx->Xi.u[1] = 0;
 907
 908     (*ctx->block) (ctx->Yi.c, ctx->EK0.c, ctx->key);
 909     ++ctr;
 910     if (is_endian.little)
 911 #ifdef BSWAP4
 912         ctx->Yi.d[3] = BSWAP4(ctr);
 913 #else
 914         PUTU32(ctx->Yi.c + 12, ctr);
 915 #endif
 916     else
 917         ctx->Yi.d[3] = ctr;
 918 }
 919
 920 int CRYPTO_gcm128_aad(GCM128_CONTEXT *ctx, const unsigned char *aad,
 921                       size_t len)
 922 {
 923     size_t i;
 924     unsigned int n;
 925     u64 alen = ctx->len.u[0];
 926 #ifdef GCM_FUNCREF_4BIT
 927     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
 928 # ifdef GHASH
 929     void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
 930                          const u8 *inp, size_t len) = ctx->ghash;
 931 # endif
 932 #endif
 933
 934     if (ctx->len.u[1])
 935         return -2;
 936
 937     alen += len;
 938     if (alen > (U64(1) << 61) || (sizeof(len) == 8 && alen < len))
 939         return -1;
 940     ctx->len.u[0] = alen;
 941
 942     n = ctx->ares;
 943     if (n) {
 944         while (n && len) {
 945             ctx->Xi.c[n] ^= *(aad++);
 946             --len;
 947             n = (n + 1) % 16;
 948         }
 949         if (n == 0)
 950             GCM_MUL(ctx);
 951         else {
 952             ctx->ares = n;
 953             return 0;
 954         }
 955     }
 956 #ifdef GHASH
 957     if ((i = (len & (size_t)-16))) {
 958         GHASH(ctx, aad, i);
 959         aad += i;
 960         len -= i;
 961     }
 962 #else
 963     while (len >= 16) {
 964         for (i = 0; i < 16; ++i)
 965             ctx->Xi.c[i] ^= aad[i];
 966         GCM_MUL(ctx);
 967         aad += 16;
 968         len -= 16;
 969     }
 970 #endif
 971     if (len) {
 972         n = (unsigned int)len;
 973         for (i = 0; i < len; ++i)
 974             ctx->Xi.c[i] ^= aad[i];
 975     }
 976
 977     ctx->ares = n;
 978     return 0;
 979 }
 980
 981 int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx,
 982                           const unsigned char *in, unsigned char *out,
 983                           size_t len)
 984 {
 985     const union {
 986         long one;
 987         char little;
 988     } is_endian = { 1 };
 989     unsigned int n, ctr;
 990     size_t i;
 991     u64 mlen = ctx->len.u[1];
 992     block128_f block = ctx->block;
 993     void *key = ctx->key;
 994 #ifdef GCM_FUNCREF_4BIT
 995     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
 996 # if defined(GHASH) && !defined(OPENSSL_SMALL_FOOTPRINT)
 997     void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
 998                          const u8 *inp, size_t len) = ctx->ghash;
 999 # endif
1000 #endif
1001
1002     mlen += len;
1003     if (mlen > ((U64(1) << 36) - 32) || (sizeof(len) == 8 && mlen < len))
1004         return -1;
1005     ctx->len.u[1] = mlen;
1006
1007     if (ctx->ares) {
1008         /* First call to encrypt finalizes GHASH(AAD) */
1009         GCM_MUL(ctx);
1010         ctx->ares = 0;
1011     }
1012
1013     if (is_endian.little)
1014 #ifdef BSWAP4
1015         ctr = BSWAP4(ctx->Yi.d[3]);
1016 #else
1017         ctr = GETU32(ctx->Yi.c + 12);
1018 #endif
1019     else
1020         ctr = ctx->Yi.d[3];
1021
1022     n = ctx->mres;
1023 #if !defined(OPENSSL_SMALL_FOOTPRINT)
1024     if (16 % sizeof(size_t) == 0) { /* always true actually */
1025         do {
1026             if (n) {
1027                 while (n && len) {
1028                     ctx->Xi.c[n] ^= *(out++) = *(in++) ^ ctx->EKi.c[n];
1029                     --len;
1030                     n = (n + 1) % 16;
1031                 }
1032                 if (n == 0)
1033                     GCM_MUL(ctx);
1034                 else {
1035                     ctx->mres = n;
1036                     return 0;
1037                 }
1038             }
1039 # if defined(STRICT_ALIGNMENT)
1040             if (((size_t)in | (size_t)out) % sizeof(size_t) != 0)
1041                 break;
1042 # endif
1043 # if defined(GHASH)
1044 #  if defined(GHASH_CHUNK)
1045             while (len >= GHASH_CHUNK) {
1046                 size_t j = GHASH_CHUNK;
1047
1048                 while (j) {
1049                     size_t *out_t = (size_t *)out;
1050                     const size_t *in_t = (const size_t *)in;
1051
1052                     (*block) (ctx->Yi.c, ctx->EKi.c, key);
1053                     ++ctr;
1054                     if (is_endian.little)
1055 #   ifdef BSWAP4
1056                         ctx->Yi.d[3] = BSWAP4(ctr);
1057 #   else
1058                         PUTU32(ctx->Yi.c + 12, ctr);
1059 #   endif
1060                     else
1061                         ctx->Yi.d[3] = ctr;
1062                     for (i = 0; i < 16 / sizeof(size_t); ++i)
1063                         out_t[i] = in_t[i] ^ ctx->EKi.t[i];
1064                     out += 16;
1065                     in += 16;
1066                     j -= 16;
1067                 }
1068                 GHASH(ctx, out - GHASH_CHUNK, GHASH_CHUNK);
1069                 len -= GHASH_CHUNK;
1070             }
1071 #  endif
1072             if ((i = (len & (size_t)-16))) {
1073                 size_t j = i;
1074
1075                 while (len >= 16) {
1076                     size_t *out_t = (size_t *)out;
1077                     const size_t *in_t = (const size_t *)in;
1078
1079                     (*block) (ctx->Yi.c, ctx->EKi.c, key);
1080                     ++ctr;
1081                     if (is_endian.little)
1082 #  ifdef BSWAP4
1083                         ctx->Yi.d[3] = BSWAP4(ctr);
1084 #  else
1085                         PUTU32(ctx->Yi.c + 12, ctr);
1086 #  endif
1087                     else
1088                         ctx->Yi.d[3] = ctr;
1089                     for (i = 0; i < 16 / sizeof(size_t); ++i)
1090                         out_t[i] = in_t[i] ^ ctx->EKi.t[i];
1091                     out += 16;
1092                     in += 16;
1093                     len -= 16;
1094                 }
1095                 GHASH(ctx, out - j, j);
1096             }
1097 # else
1098             while (len >= 16) {
1099                 size_t *out_t = (size_t *)out;
1100                 const size_t *in_t = (const size_t *)in;
1101
1102                 (*block) (ctx->Yi.c, ctx->EKi.c, key);
1103                 ++ctr;
1104                 if (is_endian.little)
1105 #  ifdef BSWAP4
1106                     ctx->Yi.d[3] = BSWAP4(ctr);
1107 #  else
1108                     PUTU32(ctx->Yi.c + 12, ctr);
1109 #  endif
1110                 else
1111                     ctx->Yi.d[3] = ctr;
1112                 for (i = 0; i < 16 / sizeof(size_t); ++i)
1113                     ctx->Xi.t[i] ^= out_t[i] = in_t[i] ^ ctx->EKi.t[i];
1114                 GCM_MUL(ctx);
1115                 out += 16;
1116                 in += 16;
1117                 len -= 16;
1118             }
1119 # endif
1120             if (len) {
1121                 (*block) (ctx->Yi.c, ctx->EKi.c, key);
1122                 ++ctr;
1123                 if (is_endian.little)
1124 # ifdef BSWAP4
1125                     ctx->Yi.d[3] = BSWAP4(ctr);
1126 # else
1127                     PUTU32(ctx->Yi.c + 12, ctr);
1128 # endif
1129                 else
1130                     ctx->Yi.d[3] = ctr;
1131                 while (len--) {
1132                     ctx->Xi.c[n] ^= out[n] = in[n] ^ ctx->EKi.c[n];
1133                     ++n;
1134                 }
1135             }
1136
1137             ctx->mres = n;
1138             return 0;
1139         } while (0);
1140     }
1141 #endif
1142     for (i = 0; i < len; ++i) {
1143         if (n == 0) {
1144             (*block) (ctx->Yi.c, ctx->EKi.c, key);
1145             ++ctr;
1146             if (is_endian.little)
1147 #ifdef BSWAP4
1148                 ctx->Yi.d[3] = BSWAP4(ctr);
1149 #else
1150                 PUTU32(ctx->Yi.c + 12, ctr);
1151 #endif
1152             else
1153                 ctx->Yi.d[3] = ctr;
1154         }
1155         ctx->Xi.c[n] ^= out[i] = in[i] ^ ctx->EKi.c[n];
1156         n = (n + 1) % 16;
1157         if (n == 0)
1158             GCM_MUL(ctx);
1159     }
1160
1161     ctx->mres = n;
1162     return 0;
1163 }
1164
1165 int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx,
1166                           const unsigned char *in, unsigned char *out,
1167                           size_t len)
1168 {
1169     const union {
1170         long one;
1171         char little;
1172     } is_endian = { 1 };
1173     unsigned int n, ctr;
1174     size_t i;
1175     u64 mlen = ctx->len.u[1];
1176     block128_f block = ctx->block;
1177     void *key = ctx->key;
1178 #ifdef GCM_FUNCREF_4BIT
1179     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
1180 # if defined(GHASH) && !defined(OPENSSL_SMALL_FOOTPRINT)
1181     void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
1182                          const u8 *inp, size_t len) = ctx->ghash;
1183 # endif
1184 #endif
1185
1186     mlen += len;
1187     if (mlen > ((U64(1) << 36) - 32) || (sizeof(len) == 8 && mlen < len))
1188         return -1;
1189     ctx->len.u[1] = mlen;
1190
1191     if (ctx->ares) {
1192         /* First call to decrypt finalizes GHASH(AAD) */
1193         GCM_MUL(ctx);
1194         ctx->ares = 0;
1195     }
1196
1197     if (is_endian.little)
1198 #ifdef BSWAP4
1199         ctr = BSWAP4(ctx->Yi.d[3]);
1200 #else
1201         ctr = GETU32(ctx->Yi.c + 12);
1202 #endif
1203     else
1204         ctr = ctx->Yi.d[3];
1205
1206     n = ctx->mres;
1207 #if !defined(OPENSSL_SMALL_FOOTPRINT)
1208     if (16 % sizeof(size_t) == 0) { /* always true actually */
1209         do {
1210             if (n) {
1211                 while (n && len) {
1212                     u8 c = *(in++);
1213                     *(out++) = c ^ ctx->EKi.c[n];
1214                     ctx->Xi.c[n] ^= c;
1215                     --len;
1216                     n = (n + 1) % 16;
1217                 }
1218                 if (n == 0)
1219                     GCM_MUL(ctx);
1220                 else {
1221                     ctx->mres = n;
1222                     return 0;
1223                 }
1224             }
1225 # if defined(STRICT_ALIGNMENT)
1226             if (((size_t)in | (size_t)out) % sizeof(size_t) != 0)
1227                 break;
1228 # endif
1229 # if defined(GHASH)
1230 #  if defined(GHASH_CHUNK)
1231             while (len >= GHASH_CHUNK) {
1232                 size_t j = GHASH_CHUNK;
1233
1234                 GHASH(ctx, in, GHASH_CHUNK);
1235                 while (j) {
1236                     size_t *out_t = (size_t *)out;
1237                     const size_t *in_t = (const size_t *)in;
1238
1239                     (*block) (ctx->Yi.c, ctx->EKi.c, key);
1240                     ++ctr;
1241                     if (is_endian.little)
1242 #   ifdef BSWAP4
1243                         ctx->Yi.d[3] = BSWAP4(ctr);
1244 #   else
1245                         PUTU32(ctx->Yi.c + 12, ctr);
1246 #   endif
1247                     else
1248                         ctx->Yi.d[3] = ctr;
1249                     for (i = 0; i < 16 / sizeof(size_t); ++i)
1250                         out_t[i] = in_t[i] ^ ctx->EKi.t[i];
1251                     out += 16;
1252                     in += 16;
1253                     j -= 16;
1254                 }
1255                 len -= GHASH_CHUNK;
1256             }
1257 #  endif
1258             if ((i = (len & (size_t)-16))) {
1259                 GHASH(ctx, in, i);
1260                 while (len >= 16) {
1261                     size_t *out_t = (size_t *)out;
1262                     const size_t *in_t = (const size_t *)in;
1263
1264                     (*block) (ctx->Yi.c, ctx->EKi.c, key);
1265                     ++ctr;
1266                     if (is_endian.little)
1267 #  ifdef BSWAP4
1268                         ctx->Yi.d[3] = BSWAP4(ctr);
1269 #  else
1270                         PUTU32(ctx->Yi.c + 12, ctr);
1271 #  endif
1272                     else
1273                         ctx->Yi.d[3] = ctr;
1274                     for (i = 0; i < 16 / sizeof(size_t); ++i)
1275                         out_t[i] = in_t[i] ^ ctx->EKi.t[i];
1276                     out += 16;
1277                     in += 16;
1278                     len -= 16;
1279                 }
1280             }
1281 # else
1282             while (len >= 16) {
1283                 size_t *out_t = (size_t *)out;
1284                 const size_t *in_t = (const size_t *)in;
1285
1286                 (*block) (ctx->Yi.c, ctx->EKi.c, key);
1287                 ++ctr;
1288                 if (is_endian.little)
1289 #  ifdef BSWAP4
1290                     ctx->Yi.d[3] = BSWAP4(ctr);
1291 #  else
1292                     PUTU32(ctx->Yi.c + 12, ctr);
1293 #  endif
1294                 else
1295                     ctx->Yi.d[3] = ctr;
1296                 for (i = 0; i < 16 / sizeof(size_t); ++i) {
1297                     size_t c = in[i];
1298                     out[i] = c ^ ctx->EKi.t[i];
1299                     ctx->Xi.t[i] ^= c;
1300                 }
1301                 GCM_MUL(ctx);
1302                 out += 16;
1303                 in += 16;
1304                 len -= 16;
1305             }
1306 # endif
1307             if (len) {
1308                 (*block) (ctx->Yi.c, ctx->EKi.c, key);
1309                 ++ctr;
1310                 if (is_endian.little)
1311 # ifdef BSWAP4
1312                     ctx->Yi.d[3] = BSWAP4(ctr);
1313 # else
1314                     PUTU32(ctx->Yi.c + 12, ctr);
1315 # endif
1316                 else
1317                     ctx->Yi.d[3] = ctr;
1318                 while (len--) {
1319                     u8 c = in[n];
1320                     ctx->Xi.c[n] ^= c;
1321                     out[n] = c ^ ctx->EKi.c[n];
1322                     ++n;
1323                 }
1324             }
1325
1326             ctx->mres = n;
1327             return 0;
1328         } while (0);
1329     }
1330 #endif
1331     for (i = 0; i < len; ++i) {
1332         u8 c;
1333         if (n == 0) {
1334             (*block) (ctx->Yi.c, ctx->EKi.c, key);
1335             ++ctr;
1336             if (is_endian.little)
1337 #ifdef BSWAP4
1338                 ctx->Yi.d[3] = BSWAP4(ctr);
1339 #else
1340                 PUTU32(ctx->Yi.c + 12, ctr);
1341 #endif
1342             else
1343                 ctx->Yi.d[3] = ctr;
1344         }
1345         c = in[i];
1346         out[i] = c ^ ctx->EKi.c[n];
1347         ctx->Xi.c[n] ^= c;
1348         n = (n + 1) % 16;
1349         if (n == 0)
1350             GCM_MUL(ctx);
1351     }
1352
1353     ctx->mres = n;
1354     return 0;
1355 }
1356
1357 int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx,
1358                                 const unsigned char *in, unsigned char *out,
1359                                 size_t len, ctr128_f stream)
1360 {
1361 #if defined(OPENSSL_SMALL_FOOTPRINT)
1362     return CRYPTO_gcm128_encrypt(ctx, in, out, len);
1363 #else
1364     const union {
1365         long one;
1366         char little;
1367     } is_endian = { 1 };
1368     unsigned int n, ctr;
1369     size_t i;
1370     u64 mlen = ctx->len.u[1];
1371     void *key = ctx->key;
1372 # ifdef GCM_FUNCREF_4BIT
1373     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
1374 #  ifdef GHASH
1375     void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
1376                          const u8 *inp, size_t len) = ctx->ghash;
1377 #  endif
1378 # endif
1379
1380     mlen += len;
1381     if (mlen > ((U64(1) << 36) - 32) || (sizeof(len) == 8 && mlen < len))
1382         return -1;
1383     ctx->len.u[1] = mlen;
1384
1385     if (ctx->ares) {
1386         /* First call to encrypt finalizes GHASH(AAD) */
1387         GCM_MUL(ctx);
1388         ctx->ares = 0;
1389     }
1390
1391     if (is_endian.little)
1392 # ifdef BSWAP4
1393         ctr = BSWAP4(ctx->Yi.d[3]);
1394 # else
1395         ctr = GETU32(ctx->Yi.c + 12);
1396 # endif
1397     else
1398         ctr = ctx->Yi.d[3];
1399
1400     n = ctx->mres;
1401     if (n) {
1402         while (n && len) {
1403             ctx->Xi.c[n] ^= *(out++) = *(in++) ^ ctx->EKi.c[n];
1404             --len;
1405             n = (n + 1) % 16;
1406         }
1407         if (n == 0)
1408             GCM_MUL(ctx);
1409         else {
1410             ctx->mres = n;
1411             return 0;
1412         }
1413     }
1414 # if defined(GHASH) && defined(GHASH_CHUNK)
1415     while (len >= GHASH_CHUNK) {
1416         (*stream) (in, out, GHASH_CHUNK / 16, key, ctx->Yi.c);
1417         ctr += GHASH_CHUNK / 16;
1418         if (is_endian.little)
1419 #  ifdef BSWAP4
1420             ctx->Yi.d[3] = BSWAP4(ctr);
1421 #  else
1422             PUTU32(ctx->Yi.c + 12, ctr);
1423 #  endif
1424         else
1425             ctx->Yi.d[3] = ctr;
1426         GHASH(ctx, out, GHASH_CHUNK);
1427         out += GHASH_CHUNK;
1428         in += GHASH_CHUNK;
1429         len -= GHASH_CHUNK;
1430     }
1431 # endif
1432     if ((i = (len & (size_t)-16))) {
1433         size_t j = i / 16;
1434
1435         (*stream) (in, out, j, key, ctx->Yi.c);
1436         ctr += (unsigned int)j;
1437         if (is_endian.little)
1438 # ifdef BSWAP4
1439             ctx->Yi.d[3] = BSWAP4(ctr);
1440 # else
1441             PUTU32(ctx->Yi.c + 12, ctr);
1442 # endif
1443         else
1444             ctx->Yi.d[3] = ctr;
1445         in += i;
1446         len -= i;
1447 # if defined(GHASH)
1448         GHASH(ctx, out, i);
1449         out += i;
1450 # else
1451         while (j--) {
1452             for (i = 0; i < 16; ++i)
1453                 ctx->Xi.c[i] ^= out[i];
1454             GCM_MUL(ctx);
1455             out += 16;
1456         }
1457 # endif
1458     }
1459     if (len) {
1460         (*ctx->block) (ctx->Yi.c, ctx->EKi.c, key);
1461         ++ctr;
1462         if (is_endian.little)
1463 # ifdef BSWAP4
1464             ctx->Yi.d[3] = BSWAP4(ctr);
1465 # else
1466             PUTU32(ctx->Yi.c + 12, ctr);
1467 # endif
1468         else
1469             ctx->Yi.d[3] = ctr;
1470         while (len--) {
1471             ctx->Xi.c[n] ^= out[n] = in[n] ^ ctx->EKi.c[n];
1472             ++n;
1473         }
1474     }
1475
1476     ctx->mres = n;
1477     return 0;
1478 #endif
1479 }
1480
1481 int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx,
1482                                 const unsigned char *in, unsigned char *out,
1483                                 size_t len, ctr128_f stream)
1484 {
1485 #if defined(OPENSSL_SMALL_FOOTPRINT)
1486     return CRYPTO_gcm128_decrypt(ctx, in, out, len);
1487 #else
1488     const union {
1489         long one;
1490         char little;
1491     } is_endian = { 1 };
1492     unsigned int n, ctr;
1493     size_t i;
1494     u64 mlen = ctx->len.u[1];
1495     void *key = ctx->key;
1496 # ifdef GCM_FUNCREF_4BIT
1497     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
1498 #  ifdef GHASH
1499     void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
1500                          const u8 *inp, size_t len) = ctx->ghash;
1501 #  endif
1502 # endif
1503
1504     mlen += len;
1505     if (mlen > ((U64(1) << 36) - 32) || (sizeof(len) == 8 && mlen < len))
1506         return -1;
1507     ctx->len.u[1] = mlen;
1508
1509     if (ctx->ares) {
1510         /* First call to decrypt finalizes GHASH(AAD) */
1511         GCM_MUL(ctx);
1512         ctx->ares = 0;
1513     }
1514
1515     if (is_endian.little)
1516 # ifdef BSWAP4
1517         ctr = BSWAP4(ctx->Yi.d[3]);
1518 # else
1519         ctr = GETU32(ctx->Yi.c + 12);
1520 # endif
1521     else
1522         ctr = ctx->Yi.d[3];
1523
1524     n = ctx->mres;
1525     if (n) {
1526         while (n && len) {
1527             u8 c = *(in++);
1528             *(out++) = c ^ ctx->EKi.c[n];
1529             ctx->Xi.c[n] ^= c;
1530             --len;
1531             n = (n + 1) % 16;
1532         }
1533         if (n == 0)
1534             GCM_MUL(ctx);
1535         else {
1536             ctx->mres = n;
1537             return 0;
1538         }
1539     }
1540 # if defined(GHASH) && defined(GHASH_CHUNK)
1541     while (len >= GHASH_CHUNK) {
1542         GHASH(ctx, in, GHASH_CHUNK);
1543         (*stream) (in, out, GHASH_CHUNK / 16, key, ctx->Yi.c);
1544         ctr += GHASH_CHUNK / 16;
1545         if (is_endian.little)
1546 #  ifdef BSWAP4
1547             ctx->Yi.d[3] = BSWAP4(ctr);
1548 #  else
1549             PUTU32(ctx->Yi.c + 12, ctr);
1550 #  endif
1551         else
1552             ctx->Yi.d[3] = ctr;
1553         out += GHASH_CHUNK;
1554         in += GHASH_CHUNK;
1555         len -= GHASH_CHUNK;
1556     }
1557 # endif
1558     if ((i = (len & (size_t)-16))) {
1559         size_t j = i / 16;
1560
1561 # if defined(GHASH)
1562         GHASH(ctx, in, i);
1563 # else
1564         while (j--) {
1565             size_t k;
1566             for (k = 0; k < 16; ++k)
1567                 ctx->Xi.c[k] ^= in[k];
1568             GCM_MUL(ctx);
1569             in += 16;
1570         }
1571         j = i / 16;
1572         in -= i;
1573 # endif
1574         (*stream) (in, out, j, key, ctx->Yi.c);
1575         ctr += (unsigned int)j;
1576         if (is_endian.little)
1577 # ifdef BSWAP4
1578             ctx->Yi.d[3] = BSWAP4(ctr);
1579 # else
1580             PUTU32(ctx->Yi.c + 12, ctr);
1581 # endif
1582         else
1583             ctx->Yi.d[3] = ctr;
1584         out += i;
1585         in += i;
1586         len -= i;
1587     }
1588     if (len) {
1589         (*ctx->block) (ctx->Yi.c, ctx->EKi.c, key);
1590         ++ctr;
1591         if (is_endian.little)
1592 # ifdef BSWAP4
1593             ctx->Yi.d[3] = BSWAP4(ctr);
1594 # else
1595             PUTU32(ctx->Yi.c + 12, ctr);
1596 # endif
1597         else
1598             ctx->Yi.d[3] = ctr;
1599         while (len--) {
1600             u8 c = in[n];
1601             ctx->Xi.c[n] ^= c;
1602             out[n] = c ^ ctx->EKi.c[n];
1603             ++n;
1604         }
1605     }
1606
1607     ctx->mres = n;
1608     return 0;
1609 #endif
1610 }
1611
1612 int CRYPTO_gcm128_finish(GCM128_CONTEXT *ctx, const unsigned char *tag,
1613                          size_t len)
1614 {
1615     const union {
1616         long one;
1617         char little;
1618     } is_endian = { 1 };
1619     u64 alen = ctx->len.u[0] << 3;
1620     u64 clen = ctx->len.u[1] << 3;
1621 #ifdef GCM_FUNCREF_4BIT
1622     void (*gcm_gmult_p) (u64 Xi[2], const u128 Htable[16]) = ctx->gmult;
1623 #endif
1624
1625     if (ctx->mres || ctx->ares)
1626         GCM_MUL(ctx);
1627
1628     if (is_endian.little) {
1629 #ifdef BSWAP8
1630         alen = BSWAP8(alen);
1631         clen = BSWAP8(clen);
1632 #else
1633         u8 *p = ctx->len.c;
1634
1635         ctx->len.u[0] = alen;
1636         ctx->len.u[1] = clen;
1637
1638         alen = (u64)GETU32(p) << 32 | GETU32(p + 4);
1639         clen = (u64)GETU32(p + 8) << 32 | GETU32(p + 12);
1640 #endif
1641     }
1642
1643     ctx->Xi.u[0] ^= alen;
1644     ctx->Xi.u[1] ^= clen;
1645     GCM_MUL(ctx);
1646
1647     ctx->Xi.u[0] ^= ctx->EK0.u[0];
1648     ctx->Xi.u[1] ^= ctx->EK0.u[1];
1649
1650     if (tag && len <= sizeof(ctx->Xi))
1651         return CRYPTO_memcmp(ctx->Xi.c, tag, len);
1652     else
1653         return -1;
1654 }
1655
1656 void CRYPTO_gcm128_tag(GCM128_CONTEXT *ctx, unsigned char *tag, size_t len)
1657 {
1658     CRYPTO_gcm128_finish(ctx, NULL, 0);
1659     memcpy(tag, ctx->Xi.c,
1660            len <= sizeof(ctx->Xi.c) ? len : sizeof(ctx->Xi.c));
1661 }
1662
1663 GCM128_CONTEXT *CRYPTO_gcm128_new(void *key, block128_f block)
1664 {
1665     GCM128_CONTEXT *ret;
1666
1667     if ((ret = OPENSSL_malloc(sizeof(*ret))) != NULL)
1668         CRYPTO_gcm128_init(ret, key, block);
1669
1670     return ret;
1671 }
1672
1673 void CRYPTO_gcm128_release(GCM128_CONTEXT *ctx)
1674 {
1675     OPENSSL_clear_free(ctx, sizeof(*ctx));
1676 }