providers/implementations/ciphers/cipher_aes_ocb.c

   1 /*
   2  * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (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 /*
  11  * AES low level APIs are deprecated for public use, but still ok for internal
  12  * use where we're using them to implement the higher level EVP interface, as is
  13  * the case here.
  14  */
  15 #include "internal/deprecated.h"
  16
  17 #include "cipher_aes_ocb.h"
  18 #include "prov/providercommonerr.h"
  19 #include "prov/ciphercommon_aead.h"
  20 #include "prov/implementations.h"
  21
  22 #define AES_OCB_FLAGS AEAD_FLAGS
  23
  24 #define OCB_DEFAULT_TAG_LEN 16
  25 #define OCB_DEFAULT_IV_LEN  12
  26 #define OCB_MIN_IV_LEN      1
  27 #define OCB_MAX_IV_LEN      15
  28
  29 PROV_CIPHER_FUNC(int, ocb_cipher, (PROV_AES_OCB_CTX *ctx,
  30                                    const unsigned char *in, unsigned char *out,
  31                                    size_t nextblock));
  32 /* forward declarations */
  33 static OSSL_FUNC_cipher_encrypt_init_fn aes_ocb_einit;
  34 static OSSL_FUNC_cipher_decrypt_init_fn aes_ocb_dinit;
  35 static OSSL_FUNC_cipher_update_fn aes_ocb_block_update;
  36 static OSSL_FUNC_cipher_final_fn aes_ocb_block_final;
  37 static OSSL_FUNC_cipher_cipher_fn aes_ocb_cipher;
  38 static OSSL_FUNC_cipher_freectx_fn aes_ocb_freectx;
  39 static OSSL_FUNC_cipher_dupctx_fn aes_ocb_dupctx;
  40 static OSSL_FUNC_cipher_get_ctx_params_fn aes_ocb_get_ctx_params;
  41 static OSSL_FUNC_cipher_set_ctx_params_fn aes_ocb_set_ctx_params;
  42
  43 /*
  44  * The following methods could be moved into PROV_AES_OCB_HW if
  45  * multiple hardware implementations are ever needed.
  46  */
  47 static ossl_inline int aes_generic_ocb_setiv(PROV_AES_OCB_CTX *ctx,
  48                                              const unsigned char *iv,
  49                                              size_t ivlen, size_t taglen)
  50 {
  51     return (CRYPTO_ocb128_setiv(&ctx->ocb, iv, ivlen, taglen) == 1);
  52 }
  53
  54 static ossl_inline int aes_generic_ocb_setaad(PROV_AES_OCB_CTX *ctx,
  55                                               const unsigned char *aad,
  56                                               size_t alen)
  57 {
  58     return CRYPTO_ocb128_aad(&ctx->ocb, aad, alen) == 1;
  59 }
  60
  61 static ossl_inline int aes_generic_ocb_gettag(PROV_AES_OCB_CTX *ctx,
  62                                               unsigned char *tag, size_t tlen)
  63 {
  64     return CRYPTO_ocb128_tag(&ctx->ocb, tag, tlen) > 0;
  65 }
  66
  67 static ossl_inline int aes_generic_ocb_final(PROV_AES_OCB_CTX *ctx)
  68 {
  69     return (CRYPTO_ocb128_finish(&ctx->ocb, ctx->tag, ctx->taglen) == 0);
  70 }
  71
  72 static ossl_inline void aes_generic_ocb_cleanup(PROV_AES_OCB_CTX *ctx)
  73 {
  74     CRYPTO_ocb128_cleanup(&ctx->ocb);
  75 }
  76
  77 static ossl_inline int aes_generic_ocb_cipher(PROV_AES_OCB_CTX *ctx,
  78                                               const unsigned char *in,
  79                                               unsigned char *out, size_t len)
  80 {
  81     if (ctx->base.enc) {
  82         if (!CRYPTO_ocb128_encrypt(&ctx->ocb, in, out, len))
  83             return 0;
  84     } else {
  85         if (!CRYPTO_ocb128_decrypt(&ctx->ocb, in, out, len))
  86             return 0;
  87     }
  88     return 1;
  89 }
  90
  91 static ossl_inline int aes_generic_ocb_copy_ctx(PROV_AES_OCB_CTX *dst,
  92                                                 PROV_AES_OCB_CTX *src)
  93 {
  94     return CRYPTO_ocb128_copy_ctx(&dst->ocb, &src->ocb,
  95                                   &dst->ksenc.ks, &dst->ksdec.ks);
  96 }
  97
  98 /*-
  99  * Provider dispatch functions
 100  */
 101 static int aes_ocb_init(void *vctx, const unsigned char *key, size_t keylen,
 102                         const unsigned char *iv, size_t ivlen, int enc)
 103 {
 104    PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
 105
 106    ctx->aad_buf_len = 0;
 107    ctx->data_buf_len = 0;
 108    ctx->base.enc = enc;
 109
 110    if (iv != NULL) {
 111        if (ivlen != ctx->base.ivlen) {
 112            /* IV len must be 1 to 15 */
 113            if (ivlen < OCB_MIN_IV_LEN || ivlen > OCB_MAX_IV_LEN) {
 114                ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
 115                return 0;
 116            }
 117            ctx->base.ivlen = ivlen;
 118        }
 119        if (!cipher_generic_initiv(&ctx->base, iv, ivlen))
 120            return 0;
 121        ctx->iv_state = IV_STATE_BUFFERED;
 122    }
 123    if (key != NULL) {
 124        if (keylen != ctx->base.keylen) {
 125            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
 126            return 0;
 127        }
 128        return ctx->base.hw->init(&ctx->base, key, keylen);
 129    }
 130    return 1;
 131 }
 132
 133 static int aes_ocb_einit(void *vctx, const unsigned char *key, size_t keylen,
 134                          const unsigned char *iv, size_t ivlen)
 135 {
 136     return aes_ocb_init(vctx, key, keylen, iv, ivlen, 1);
 137 }
 138
 139 static int aes_ocb_dinit(void *vctx, const unsigned char *key, size_t keylen,
 140                          const unsigned char *iv, size_t ivlen)
 141 {
 142     return aes_ocb_init(vctx, key, keylen, iv, ivlen, 0);
 143 }
 144
 145 /*
 146  * Because of the way OCB works, both the AAD and data are buffered in the
 147  * same way. Only the last block can be a partial block.
 148  */
 149 static int aes_ocb_block_update_internal(PROV_AES_OCB_CTX *ctx,
 150                                          unsigned char *buf, size_t *bufsz,
 151                                          unsigned char *out, size_t *outl,
 152                                          size_t outsize, const unsigned char *in,
 153                                          size_t inl, OSSL_ocb_cipher_fn ciph)
 154 {
 155     size_t nextblocks;
 156     size_t outlint = 0;
 157
 158     if (*bufsz != 0)
 159         nextblocks = fillblock(buf, bufsz, AES_BLOCK_SIZE, &in, &inl);
 160     else
 161         nextblocks = inl & ~(AES_BLOCK_SIZE-1);
 162
 163     if (*bufsz == AES_BLOCK_SIZE) {
 164         if (outsize < AES_BLOCK_SIZE) {
 165             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 166             return 0;
 167         }
 168         if (!ciph(ctx, buf, out, AES_BLOCK_SIZE)) {
 169             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 170             return 0;
 171         }
 172         *bufsz = 0;
 173         outlint = AES_BLOCK_SIZE;
 174         out += AES_BLOCK_SIZE;
 175     }
 176     if (nextblocks > 0) {
 177         outlint += nextblocks;
 178         if (outsize < outlint) {
 179             ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 180             return 0;
 181         }
 182         if (!ciph(ctx, in, out, nextblocks)) {
 183             ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 184             return 0;
 185         }
 186         in += nextblocks;
 187         inl -= nextblocks;
 188     }
 189     if (inl != 0 && !trailingdata(buf, bufsz, AES_BLOCK_SIZE, &in, &inl)) {
 190         /* PROVerr already called */
 191         return 0;
 192     }
 193
 194     *outl = outlint;
 195     return inl == 0;
 196 }
 197
 198 /* A wrapper function that has the same signature as cipher */
 199 static int cipher_updateaad(PROV_AES_OCB_CTX *ctx, const unsigned char *in,
 200                             unsigned char *out, size_t len)
 201 {
 202     return aes_generic_ocb_setaad(ctx, in, len);
 203 }
 204
 205 static int update_iv(PROV_AES_OCB_CTX *ctx)
 206 {
 207     if (ctx->iv_state == IV_STATE_FINISHED
 208         || ctx->iv_state == IV_STATE_UNINITIALISED)
 209         return 0;
 210     if (ctx->iv_state == IV_STATE_BUFFERED) {
 211         if (!aes_generic_ocb_setiv(ctx, ctx->base.iv, ctx->base.ivlen,
 212                                    ctx->taglen))
 213             return 0;
 214         ctx->iv_state = IV_STATE_COPIED;
 215     }
 216     return 1;
 217 }
 218
 219 static int aes_ocb_block_update(void *vctx, unsigned char *out, size_t *outl,
 220                                 size_t outsize, const unsigned char *in,
 221                                 size_t inl)
 222 {
 223     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
 224     unsigned char *buf;
 225     size_t *buflen;
 226     OSSL_ocb_cipher_fn fn;
 227
 228     if (!ctx->key_set || !update_iv(ctx))
 229         return 0;
 230
 231     if (inl == 0) {
 232         *outl = 0;
 233         return 1;
 234     }
 235
 236     /* Are we dealing with AAD or normal data here? */
 237     if (out == NULL) {
 238         buf = ctx->aad_buf;
 239         buflen = &ctx->aad_buf_len;
 240         fn = cipher_updateaad;
 241     } else {
 242         buf = ctx->data_buf;
 243         buflen = &ctx->data_buf_len;
 244         fn = aes_generic_ocb_cipher;
 245     }
 246     return aes_ocb_block_update_internal(ctx, buf, buflen, out, outl, outsize,
 247                                          in, inl, fn);
 248 }
 249
 250 static int aes_ocb_block_final(void *vctx, unsigned char *out, size_t *outl,
 251                                size_t outsize)
 252 {
 253     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
 254
 255     /* If no block_update has run then the iv still needs to be set */
 256     if (!ctx->key_set || !update_iv(ctx))
 257         return 0;
 258
 259     /*
 260      * Empty the buffer of any partial block that we might have been provided,
 261      * both for data and AAD
 262      */
 263     *outl = 0;
 264     if (ctx->data_buf_len > 0) {
 265         if (!aes_generic_ocb_cipher(ctx, ctx->data_buf, out, ctx->data_buf_len))
 266             return 0;
 267         *outl = ctx->data_buf_len;
 268         ctx->data_buf_len = 0;
 269     }
 270     if (ctx->aad_buf_len > 0) {
 271         if (!aes_generic_ocb_setaad(ctx, ctx->aad_buf, ctx->aad_buf_len))
 272             return 0;
 273         ctx->aad_buf_len = 0;
 274     }
 275     if (ctx->base.enc) {
 276         /* If encrypting then just get the tag */
 277         if (!aes_generic_ocb_gettag(ctx, ctx->tag, ctx->taglen))
 278             return 0;
 279     } else {
 280         /* If decrypting then verify */
 281         if (ctx->taglen == 0)
 282             return 0;
 283         if (!aes_generic_ocb_final(ctx))
 284             return 0;
 285     }
 286     /* Don't reuse the IV */
 287     ctx->iv_state = IV_STATE_FINISHED;
 288     return 1;
 289 }
 290
 291 static void *aes_ocb_newctx(void *provctx, size_t kbits, size_t blkbits,
 292                             size_t ivbits, unsigned int mode, uint64_t flags)
 293 {
 294     PROV_AES_OCB_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
 295
 296     if (ctx != NULL) {
 297         cipher_generic_initkey(ctx, kbits, blkbits, ivbits, mode, flags,
 298                                PROV_CIPHER_HW_aes_ocb(kbits), NULL);
 299         ctx->taglen = OCB_DEFAULT_TAG_LEN;
 300     }
 301     return ctx;
 302 }
 303
 304 static void aes_ocb_freectx(void *vctx)
 305 {
 306     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
 307
 308     if (ctx != NULL) {
 309         aes_generic_ocb_cleanup(ctx);
 310         cipher_generic_reset_ctx((PROV_CIPHER_CTX *)vctx);
 311         OPENSSL_clear_free(ctx,  sizeof(*ctx));
 312     }
 313 }
 314
 315 static void *aes_ocb_dupctx(void *vctx)
 316 {
 317     PROV_AES_OCB_CTX *in = (PROV_AES_OCB_CTX *)vctx;
 318     PROV_AES_OCB_CTX *ret = OPENSSL_malloc(sizeof(*ret));
 319
 320     if (ret == NULL) {
 321         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
 322         return NULL;
 323     }
 324     *ret = *in;
 325     if (!aes_generic_ocb_copy_ctx(ret, in)) {
 326         OPENSSL_free(ret);
 327         ret = NULL;
 328     }
 329     return ret;
 330 }
 331
 332 static int aes_ocb_set_ctx_params(void *vctx, const OSSL_PARAM params[])
 333 {
 334     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
 335     const OSSL_PARAM *p;
 336     size_t sz;
 337
 338     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_TAG);
 339     if (p != NULL) {
 340         if (p->data_type != OSSL_PARAM_OCTET_STRING) {
 341             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 342             return 0;
 343         }
 344         if (p->data == NULL) {
 345             /* Tag len must be 0 to 16 */
 346             if (p->data_size > OCB_MAX_TAG_LEN)
 347                 return 0;
 348             ctx->taglen = p->data_size;
 349         } else {
 350             if (p->data_size != ctx->taglen || ctx->base.enc)
 351                 return 0;
 352             memcpy(ctx->tag, p->data, p->data_size);
 353         }
 354      }
 355     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_IVLEN);
 356     if (p != NULL) {
 357         if (!OSSL_PARAM_get_size_t(p, &sz)) {
 358             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 359             return 0;
 360         }
 361         /* IV len must be 1 to 15 */
 362         if (sz < OCB_MIN_IV_LEN || sz > OCB_MAX_IV_LEN)
 363             return 0;
 364         ctx->base.ivlen = sz;
 365     }
 366     p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN);
 367     if (p != NULL) {
 368         size_t keylen;
 369
 370         if (!OSSL_PARAM_get_size_t(p, &keylen)) {
 371             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 372             return 0;
 373         }
 374         if (ctx->base.keylen != keylen) {
 375             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
 376             return 0;
 377         }
 378     }
 379     return 1;
 380 }
 381
 382 static int aes_ocb_get_ctx_params(void *vctx, OSSL_PARAM params[])
 383 {
 384     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
 385     OSSL_PARAM *p;
 386
 387     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
 388     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->base.ivlen)) {
 389         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 390         return 0;
 391     }
 392     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
 393     if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->base.keylen)) {
 394         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 395         return 0;
 396     }
 397     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TAGLEN);
 398     if (p != NULL) {
 399         if (!OSSL_PARAM_set_size_t(p, ctx->taglen)) {
 400             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 401             return 0;
 402         }
 403     }
 404
 405     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IV);
 406     if (p != NULL) {
 407         if (ctx->base.ivlen > p->data_size) {
 408             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
 409             return 0;
 410         }
 411         if (!OSSL_PARAM_set_octet_string(p, ctx->base.oiv, ctx->base.ivlen)
 412             && !OSSL_PARAM_set_octet_ptr(p, &ctx->base.oiv, ctx->base.ivlen)) {
 413             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
 414             return 0;
 415         }
 416     }
 417     p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TAG);
 418     if (p != NULL) {
 419         if (p->data_type != OSSL_PARAM_OCTET_STRING) {
 420             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
 421             return 0;
 422         }
 423         if (!ctx->base.enc || p->data_size != ctx->taglen) {
 424             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAGLEN);
 425             return 0;
 426         }
 427         memcpy(p->data, ctx->tag, ctx->taglen);
 428     }
 429     return 1;
 430 }
 431
 432 static const OSSL_PARAM cipher_ocb_known_gettable_ctx_params[] = {
 433     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
 434     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
 435     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL),
 436     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
 437     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
 438     OSSL_PARAM_END
 439 };
 440 static const OSSL_PARAM *cipher_ocb_gettable_ctx_params(void)
 441 {
 442     return cipher_ocb_known_gettable_ctx_params;
 443 }
 444
 445 static const OSSL_PARAM cipher_ocb_known_settable_ctx_params[] = {
 446     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
 447     OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL),
 448     OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
 449     OSSL_PARAM_END
 450 };
 451 static const OSSL_PARAM *cipher_ocb_settable_ctx_params(void)
 452 {
 453     return cipher_ocb_known_settable_ctx_params;
 454 }
 455
 456 static int aes_ocb_cipher(void *vctx, unsigned char *out, size_t *outl,
 457                           size_t outsize, const unsigned char *in, size_t inl)
 458 {
 459     PROV_AES_OCB_CTX *ctx = (PROV_AES_OCB_CTX *)vctx;
 460
 461     if (outsize < inl) {
 462         ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL);
 463         return 0;
 464     }
 465
 466     if (!aes_generic_ocb_cipher(ctx, in, out, inl)) {
 467         ERR_raise(ERR_LIB_PROV, PROV_R_CIPHER_OPERATION_FAILED);
 468         return 0;
 469     }
 470
 471     *outl = inl;
 472     return 1;
 473 }
 474
 475 #define IMPLEMENT_cipher(mode, UCMODE, flags, kbits, blkbits, ivbits)          \
 476 static OSSL_FUNC_cipher_get_params_fn aes_##kbits##_##mode##_get_params;       \
 477 static int aes_##kbits##_##mode##_get_params(OSSL_PARAM params[])              \
 478 {                                                                              \
 479     return cipher_generic_get_params(params, EVP_CIPH_##UCMODE##_MODE,         \
 480                                      flags, kbits, blkbits, ivbits);           \
 481 }                                                                              \
 482 static OSSL_FUNC_cipher_newctx_fn aes_##kbits##_##mode##_newctx;               \
 483 static void *aes_##kbits##_##mode##_newctx(void *provctx)                      \
 484 {                                                                              \
 485     return aes_##mode##_newctx(provctx, kbits, blkbits, ivbits,                \
 486                                EVP_CIPH_##UCMODE##_MODE, flags);               \
 487 }                                                                              \
 488 const OSSL_DISPATCH aes##kbits##mode##_functions[] = {                         \
 489     { OSSL_FUNC_CIPHER_NEWCTX,                                                 \
 490         (void (*)(void))aes_##kbits##_##mode##_newctx },                       \
 491     { OSSL_FUNC_CIPHER_ENCRYPT_INIT, (void (*)(void))aes_##mode##_einit },     \
 492     { OSSL_FUNC_CIPHER_DECRYPT_INIT, (void (*)(void))aes_##mode##_dinit },     \
 493     { OSSL_FUNC_CIPHER_UPDATE, (void (*)(void))aes_##mode##_block_update },    \
 494     { OSSL_FUNC_CIPHER_FINAL, (void (*)(void))aes_##mode##_block_final },      \
 495     { OSSL_FUNC_CIPHER_CIPHER, (void (*)(void))aes_ocb_cipher },               \
 496     { OSSL_FUNC_CIPHER_FREECTX, (void (*)(void))aes_##mode##_freectx },        \
 497     { OSSL_FUNC_CIPHER_DUPCTX, (void (*)(void))aes_##mode##_dupctx },          \
 498     { OSSL_FUNC_CIPHER_GET_PARAMS,                                             \
 499         (void (*)(void))aes_##kbits##_##mode##_get_params },                   \
 500     { OSSL_FUNC_CIPHER_GET_CTX_PARAMS,                                         \
 501         (void (*)(void))aes_##mode##_get_ctx_params },                         \
 502     { OSSL_FUNC_CIPHER_SET_CTX_PARAMS,                                         \
 503         (void (*)(void))aes_##mode##_set_ctx_params },                         \
 504     { OSSL_FUNC_CIPHER_GETTABLE_PARAMS,                                        \
 505         (void (*)(void))cipher_generic_gettable_params },                      \
 506     { OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS,                                    \
 507         (void (*)(void))cipher_ocb_gettable_ctx_params },                      \
 508     { OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS,                                    \
 509         (void (*)(void))cipher_ocb_settable_ctx_params },                      \
 510     { 0, NULL }                                                                \
 511 }
 512
 513 IMPLEMENT_cipher(ocb, OCB, AES_OCB_FLAGS, 256, 128, OCB_DEFAULT_IV_LEN * 8);
 514 IMPLEMENT_cipher(ocb, OCB, AES_OCB_FLAGS, 192, 128, OCB_DEFAULT_IV_LEN * 8);
 515 IMPLEMENT_cipher(ocb, OCB, AES_OCB_FLAGS, 128, 128, OCB_DEFAULT_IV_LEN * 8);
 516