From 09734e51d918e508ecbe9aab8843544f29f23cb6 Mon Sep 17 00:00:00 2001 From: Mark Wooding Date: Sat, 3 Nov 2018 10:54:40 +0000 Subject: [PATCH] symm/ocb3.h, symm/ocb3-def.h: Implement the OCB3 auth'ned encryption mode. Note that there is no PMAC3 corresponding to OCB3, like there is for the previous two versions. The OCB3 header-processing is not a secure standalone MAC. --- symm/Makefile.am | 2 +- symm/ocb3-def.h | 1006 +++++++++++++++++++++++++++++++++++++++++++++++++ symm/ocb3.h | 337 +++++++++++++++++ symm/t/blowfish | 216 +++++++++++ symm/t/cast128 | 195 ++++++++++ symm/t/cast256.local | 201 ++++++++++ symm/t/des | 96 +++++ symm/t/des3 | 192 ++++++++++ symm/t/desx | 192 ++++++++++ symm/t/idea | 50 +++ symm/t/mars.local | 207 ++++++++++ symm/t/noekeon | 51 +++ symm/t/rc2 | 195 ++++++++++ symm/t/rc5 | 216 +++++++++++ symm/t/rijndael.local | 305 +++++++++++++++ symm/t/rijndael192 | 214 +++++++++++ symm/t/rijndael256 | 214 +++++++++++ symm/t/safer | 96 +++++ symm/t/safersk | 96 +++++ symm/t/serpent.local | 213 +++++++++++ symm/t/skipjack | 51 +++ symm/t/square | 144 +++++++ symm/t/tea | 195 ++++++++++ symm/t/twofish.local | 201 ++++++++++ symm/t/xtea | 195 ++++++++++ utils/advmodes | 220 ++++++++++- 26 files changed, 5298 insertions(+), 2 deletions(-) create mode 100644 symm/ocb3-def.h create mode 100644 symm/ocb3.h diff --git a/symm/Makefile.am b/symm/Makefile.am index 887cbf4d..82b1c960 100644 --- a/symm/Makefile.am +++ b/symm/Makefile.am @@ -321,7 +321,7 @@ BLKCMACMODES += cmac pmac1 ## Various AEAD modes. pkginclude_HEADERS += ocb.h -BLKCAEADMODES += ccm eax gcm ocb1 +BLKCAEADMODES += ccm eax gcm ocb1 ocb3 libsymm_la_SOURCES += ccm.c gcm.c ocb.c ###-------------------------------------------------------------------------- diff --git a/symm/ocb3-def.h b/symm/ocb3-def.h new file mode 100644 index 00000000..14a22f61 --- /dev/null +++ b/symm/ocb3-def.h @@ -0,0 +1,1006 @@ +/* -*-c-*- + * + * The OCB3 authenticated encryption mode + * + * (c) 2018 Straylight/Edgeware + */ + +/*----- Licensing notice --------------------------------------------------* + * + * This file is part of Catacomb. + * + * Catacomb is free software: you can redistribute it and/or modify it + * under the terms of the GNU Library General Public License as published + * by the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * Catacomb is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with Catacomb. If not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifndef CATACOMB_OCB3_DEF_H +#define CATACOMB_OCB3_DEF_H + +#ifdef __cplusplus + extern "C" { +#endif + +/*----- Header files ------------------------------------------------------*/ + +#include + +#include +#include + +#ifndef CATACOMB_ARENA_H +# include "arena.h" +#endif + +#ifndef CATACOMB_BLKC_H +# include "blkc.h" +#endif + +#ifndef CATACOMB_CT_H +# include "ct.h" +#endif + +#ifndef CATACOMB_KEYSZ_H +# include "keysz.h" +#endif + +#ifndef CATACOMB_RSVR_H +# include "rsvr.h" +#endif + +#ifndef CATACOMB_PARANOIA_H +# include "paranoia.h" +#endif + +/*----- Macros ------------------------------------------------------------*/ + +#define OCB3_TSHIFT(PRE) BLKC_GLUE(OCB3_TSHIFT_, BLKC_BITS(PRE)) +#define OCB3_TSHIFT_64 2 +#define OCB3_TSHIFT_96 1 +#define OCB3_TSHIFT_128 1 +#define OCB3_TSHIFT_192 0 +#define OCB3_TSHIFT_256 0 + +#define OCB3_STRETCHMASK(PRE) BLKC_GLUE(OCB3_STRETCHMASK_, BLKC_BITS(PRE)) +#define OCB3_STRETCHMASK_64 0x1f +#define OCB3_STRETCHMASK_96 0x3f +#define OCB3_STRETCHMASK_128 0x3f +#define OCB3_STRETCHMASK_192 0x7f +#define OCB3_STRETCHMASK_256 0xff + +#define OCB3_STRETCHSHIFT(PRE) BLKC_GLUE(OCB3_STRETCHSHIFT_, BLKC_BITS(PRE)) +#define OCB3_STRETCHSHIFT_64 25 +#define OCB3_STRETCHSHIFT_96 33 +#define OCB3_STRETCHSHIFT_128 8 +#define OCB3_STRETCHSHIFT_192 40 +#define OCB3_STRETCHSHIFT_256 1 + +/* --- @OCB3_DEF@ --- * + * + * Arguments: @PRE@, @pre@ = prefixes for the underlying block cipher + * + * Use: Creates an implementation for the OCB3 authenticated- + * encryption mode. + */ + +#define OCB3_DEF(PRE, pre) OCB3_DEFX(PRE, pre, #pre, #pre) + +#define OCB3_DEFX(PRE, pre, name, fname) \ + \ +static const rsvr_policy pre##_ocb3policy = \ + { 0, PRE##_BLKSZ, PRE##_BLKSZ }; \ + \ +const octet \ + pre##_ocb3noncesz[] = { KSZ_RANGE, OCB3_NSZMAX(PRE), \ + 0, OCB3_NSZMAX(PRE), 1 }, \ + pre##_ocb3tagsz[] = { KSZ_RANGE, PRE##_BLKSZ, 0, PRE##_BLKSZ, 1 }; \ + \ +/* --- @pre_ocb3setkey@ --- * \ + * \ + * Arguments: @pre_ocb3key *key@ = pointer to OCB3 key block \ + * @ocnst void *k@ = pointer to key material \ + * @size_t ksz@ = size of key material \ + * \ + * Returns: --- \ + * \ + * Use: Initializes a OCB3 key. This can be used for \ + * several encryption/or MAC operations. \ + */ \ + \ +void pre##_ocb3setkey(pre##_ocb3key *key, const void *k, size_t ksz) \ +{ \ + unsigned i; \ + \ + pre##_init(&key->ctx, k, ksz); \ + BLKC_ZERO(PRE, key->lstar); \ + pre##_eblk(&key->ctx, key->lstar, key->lstar); \ + BLKC_BLSHIFT(PRE, IRRED, key->ldollar, key->lstar); \ + BLKC_BLSHIFT(PRE, IRRED, key->lmask[0], key->ldollar); \ + for (i = 1; i < OCB_NCALC; i++) \ + BLKC_BLSHIFT(PRE, IRRED, key->lmask[i], key->lmask[i - 1]); \ +} \ + \ +/* --- @pre_ocb3aadinit@ --- * \ + * \ + * Arguments: @pre_ocb3aadctx *aad@ = pointer to context block \ + * @pre_ocb3key *k@ = key block \ + * \ + * Returns: --- \ + * \ + * Use: Initializes an OCB3 AAD (`additional authenticated \ + * data') context associated witha a given key. \ + * AAD contexts can be copied and/or reused, saving time \ + * if the AAD for a number of messages has a common \ + * prefix. \ + * \ + * The @key@ doesn't need to be kept around. \ + */ \ + \ +void pre##_ocb3aadinit(pre##_ocb3aadctx *aad, const pre##_ocb3key *k) \ +{ \ + aad->k = *k; \ + aad->off = 0; aad->i = 1; \ + BLKC_ZERO(PRE, aad->a); \ + BLKC_ZERO(PRE, aad->o); \ +} \ + \ +/* --- @pre_ocb3aadhash@ --- * \ + * \ + * Arguments: @pre_ocb3aadctx *aad@ = pointer to context block \ + * @ocnst void *p@ = pointer to message buffer \ + * @size_t sz@ = size of message buffer \ + * \ + * Returns: --- \ + * \ + * Use: Hashes some AAD input data. \ + */ \ + \ +void pre##_ocb3aadhash(pre##_ocb3aadctx *aad, const void *p, size_t sz) \ +{ \ + rsvr_state st; \ + uint32 t[PRE##_BLKSZ/4]; \ + const octet *q; \ + \ + rsvr_setup(&st, &pre##_ocb3policy, aad->b, &aad->off, p, sz); \ + RSVR_DO(&st) while ((q = RSVR_NEXT(&st, PRE##_BLKSZ)) != 0) { \ + OCB_OFFSET(PRE, aad->o, aad->k.lmask, aad->i++); \ + BLKC_LOAD(PRE, t, q); BLKC_XMOVE(PRE, t, aad->o); \ + pre##_eblk(&aad->k.ctx, t, t); \ + BLKC_XMOVE(PRE, aad->a, t); \ + } \ +} \ + \ +/* --- @pre_ocb3augment@ --- * \ + * \ + * Arguments: @uint32 *nn@ = where to write the augmented nonce \ + * @const octet *n@ = pointer to input nonce data \ + * @size_t nsz@ = size of input nonce \ + * @size_t tsz@ = tag length \ + * \ + * Returns: The nonce shift index. \ + * \ + * Use: Constructs the augmented base nonce, mixing in the tag \ + * length appropriately. \ + */ \ + \ +static unsigned pre##_ocb3augment(uint32 *nn, const octet *n, \ + size_t nsz, size_t tsz) \ +{ \ + octet b[PRE##_BLKSZ] = { 0 }; \ + uint32 t; \ + unsigned nix; \ + \ + b[0] = 8*(tsz%PRE##_BLKSZ) << OCB3_TSHIFT(PRE); \ + b[PRE##_BLKSZ - nsz - 1] |= 0x01; \ + memcpy(b + PRE##_BLKSZ - nsz, n, nsz); \ + BLKC_LOAD(PRE, nn, b); \ + t = BLKC_BWORD(PRE, nn[PRE##_BLKSZ/4 - 1]); \ + nix = t&OCB3_STRETCHMASK(PRE); \ + t &= ~(uint32)OCB3_STRETCHMASK(PRE); \ + nn[PRE##_BLKSZ/4 - 1] = BLKC_BWORD(PRE, t); \ + return (nix); \ +} \ + \ +/* --- @pre_ocb3stretch@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to OCB3 context \ + * \ + * Returns: --- \ + * \ + * Use: Stretches the augmented nonce. \ + */ \ + \ +static void pre##_ocb3stretch(pre##_ocb3ctx *ctx) \ +{ \ + unsigned nw = OCB3_STRETCHSHIFT(PRE)/32, \ + nl = OCB3_STRETCHSHIFT(PRE)%32, nr = 32 - nl; \ + unsigned i; \ + uint32 c = 0, t, u; \ + \ + pre##_eblk(&ctx->k.ctx, ctx->nbase, ctx->nstretch); \ + for (i = 0; i < PRE##_BLKSZ/4; i++) \ + ctx->nstretch[i] = BLKC_BWORD(PRE, ctx->nstretch[i]); \ + i = PRE##_BLKSZ/4; \ + while (i > PRE##_BLKSZ/4 - nw) \ + { i--; ctx->nstretch[i + PRE##_BLKSZ/4] = ctx->nstretch[i]; } \ + while (i--) { \ + u = ctx->nstretch[i]; t = ctx->nstretch[i + nw]; \ + ctx->nstretch[i + PRE##_BLKSZ/4] = u ^ (t << nl) ^ c; \ + if (nr < 32) c = U32(t) >> nr; \ + } \ +} \ + \ +/* --- @pre_ocb3shift@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to OCB3 context \ + * @unsigned nix@ = nonce index \ + * \ + * Returns: --- \ + * \ + * Use: Extracts a chunk out of the OCB3 stretched nonce and \ + * writes it to @ctx->o@. \ + */ \ + \ +static void pre##_ocb3shift(pre##_ocb3ctx *ctx, unsigned nix) \ +{ \ + unsigned nw = nix/32, nl = nix%32, nr = 32 - nl; \ + uint32 c, t; \ + unsigned i; \ + \ + i = PRE##_BLKSZ/4; \ + if (nr < 32) c = U32(ctx->nstretch[PRE##_BLKSZ/4 + nw]) >> nr; \ + else c = 0; \ + while (i--) { \ + t = ctx->nstretch[i + nw]; \ + ctx->o[i] = BLKC_BWORD(PRE, (t << nl) | c); \ + if (nr < 32) c = U32(t) >> nr; \ + } \ +} \ + \ +/* --- @pre_ocb3init@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to OCB3 context \ + * @const pre_ocb3key *key@ = pointer to key block \ + * @const void *n@ = pointer to nonce \ + * @size_t nsz@ = size of nonce \ + * @size_t tsz@ = tag length \ + * \ + * Returns: Zero on success, @-1@ if the nonce or tag length is \ + * bad. \ + * \ + * Use: Initialize an OCB3 operation context with a given key. \ + * \ + * The original key needn't be kept around any more. \ + */ \ + \ +int pre##_ocb3init(pre##_ocb3ctx *ctx, const pre##_ocb3key *k, \ + const void *n, size_t nsz, size_t tsz) \ +{ \ + unsigned nix; \ + \ + /* Preflight checking. */ \ + if (nsz > OCB3_NSZMAX(PRE)) return (-1); \ + if (tsz > PRE##_BLKSZ) return (-1); \ + \ + /* Copy over the blockcipher key. */ \ + ctx->k = *k; \ + \ + /* Sort out the nonce. */ \ + nix = pre##_ocb3augment(ctx->nbase, n, nsz, tsz); \ + ctx->nix = nix; ctx->tsz = tsz; \ + pre##_ocb3stretch(ctx); \ + pre##_ocb3shift(ctx, nix); \ + \ + /* Other random things. */ \ + ctx->off = 0; ctx->i = 1; \ + BLKC_ZERO(PRE, ctx->a); \ + \ + /* Done. */ \ + return (0); \ +} \ + \ +/* --- @pre_ocb3reinit@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to OCB3 context \ + * @const void *n@ = pointer to nonce \ + * @size_t nsz@ = size of nonce \ + * @size_t tsz@ = tag length \ + * \ + * Returns: Zero on success, @-1@ if the nonce or tag length is \ + * bad. \ + * \ + * Use: Reinitialize an OCB3 operation context, changing the \ + * nonce and/or tag length. \ + */ \ + \ +int pre##_ocb3reinit(pre##_ocb3ctx *ctx, \ + const void *n, size_t nsz, size_t tsz) \ +{ \ + uint32 t[PRE##_BLKSZ/4]; \ + unsigned nix, i; \ + \ + /* Preflight checking. */ \ + if (nsz > OCB3_NSZMAX(PRE)) return (-1); \ + if (tsz > PRE##_BLKSZ) return (-1); \ + \ + /* Sort out the nonce. */ \ + nix = pre##_ocb3augment(t, n, nsz, tsz); \ + for (i = 0; i < PRE##_BLKSZ/4; i++) { \ + if (t[i] == ctx->nbase[i]) continue; \ + ctx->nix = nix; ctx->tsz = tsz; \ + BLKC_MOVE(PRE, ctx->nbase, t); pre##_ocb3stretch(ctx); \ + break; \ + } \ + pre##_ocb3shift(ctx, nix); \ + \ + /* Other random things. */ \ + ctx->off = 0; ctx->i = 1; \ + BLKC_ZERO(PRE, ctx->a); \ + \ + /* Done. */ \ + return (0); \ +} \ + \ +/* --- @pre_ocb3step@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to OCB3 context \ + * \ + * Returns: --- \ + * \ + * Use: Reinitialize an OCB3 operation context, stepping to \ + * the `next' nonce along. \ + */ \ + \ +void pre##_ocb3step(pre##_ocb3ctx *ctx) \ +{ \ + /* Sort out the nonce. */ \ + if (ctx->nix < OCB3_STRETCHMASK(PRE)) \ + pre##_ocb3shift(ctx, ++ctx->nix); \ + else { \ + ctx->nix = 0; \ + BLKC_BADD(PRE, ctx->nbase, OCB3_STRETCHMASK(PRE) + 1); \ + pre##_ocb3stretch(ctx); \ + pre##_ocb3shift(ctx, 0); \ + } \ + \ + /* Other random things. */ \ + ctx->off = 0; ctx->i = 1; \ + BLKC_ZERO(PRE, ctx->a); \ +} \ + \ +/* --- @pre_ocb3encrypt@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to OCB3 operation context \ + * @const void *src@ = pointer to plaintext message chunk \ + * @size_t sz@ = size of the plaintext \ + * @buf *dst@ = a buffer to write the ciphertext to \ + * \ + * Returns: Zero on success; @-1@ on failure. \ + * \ + * Use: Encrypts a chunk of a plaintext message, writing a \ + * chunk of ciphertext to the output buffer and updating \ + * the operation state. \ + * \ + * Note that OCB3 delays output if its input is not a \ + * whole number of blocks. This means that the output \ + * might be smaller or larger the input by up to the block \ + * size. \ + */ \ + \ +int pre##_ocb3encrypt(pre##_ocb3ctx *ctx, \ + const void *src, size_t sz, buf *dst) \ +{ \ + rsvr_state st; \ + size_t osz; \ + uint32 t[PRE##_BLKSZ/4]; \ + const octet *p; \ + octet *q; \ + \ + /* Figure out what we're going to do. */ \ + rsvr_setup(&st, &pre##_ocb3policy, ctx->b, &ctx->off, src, sz); \ + \ + /* Determine the output size and verify that there is enough \ + * space. \ + */ \ + osz = st.plan.from_rsvr + st.plan.from_input; \ + if (!osz) q = 0; \ + else { q = buf_get(dst, osz); if (!q) return (-1); } \ + \ + /* Process the input in whole blocks at a time. */ \ + RSVR_DO(&st) while ((p = RSVR_NEXT(&st, PRE##_BLKSZ)) != 0) { \ + OCB_OFFSET(PRE, ctx->o, ctx->k.lmask, ctx->i++); \ + BLKC_LOAD(PRE, t, p); BLKC_XMOVE(PRE, ctx->a, t); \ + BLKC_XMOVE(PRE, t, ctx->o); pre##_eblk(&ctx->k.ctx, t, t); \ + BLKC_XSTORE(PRE, q, t, ctx->o); q += PRE##_BLKSZ; \ + } \ + \ + /* Done. */ \ + return (0); \ +} \ + \ +/* --- @pre_ocb3decrypt@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to OCB3 operation context \ + * @const void *src@ = pointer to ciphertext message chunk \ + * @size_t sz@ = size of the ciphertext \ + * @buf *dst@ = a buffer to write the plaintext to \ + * \ + * Returns: Zero on success; @-1@ on failure. \ + * \ + * Use: Decrypts a chunk of a ciphertext message, writing a \ + * chunk of plaintext to the output buffer and updating \ + * the operation state. \ + * \ + * Note that OCB3 delays output if its input is not a \ + * whole number of blocks. This means that the output \ + * might be smaller or larger the input by up to the block \ + * size. \ + */ \ + \ +int pre##_ocb3decrypt(pre##_ocb3ctx *ctx, \ + const void *src, size_t sz, buf *dst) \ +{ \ + rsvr_state st; \ + size_t osz; \ + uint32 t[PRE##_BLKSZ/4]; \ + const octet *p; \ + octet *q; \ + \ + /* Figure out what we're going to do. */ \ + rsvr_setup(&st, &pre##_ocb3policy, ctx->b, &ctx->off, src, sz); \ + \ + /* Determine the output size and verify that there is enough \ + * space. \ + */ \ + osz = st.plan.from_rsvr + st.plan.from_input; \ + if (!osz) q = 0; \ + else { q = buf_get(dst, osz); if (!q) return (-1); } \ + \ + /* Process the input in whole blocks at a time. */ \ + RSVR_DO(&st) while ((p = RSVR_NEXT(&st, PRE##_BLKSZ)) != 0) { \ + OCB_OFFSET(PRE, ctx->o, ctx->k.lmask, ctx->i++); \ + BLKC_LOAD(PRE, t, p); \ + BLKC_XMOVE(PRE, t, ctx->o); pre##_dblk(&ctx->k.ctx, t, t); \ + BLKC_XMOVE(PRE, t, ctx->o); BLKC_XMOVE(PRE, ctx->a, t); \ + BLKC_STORE(PRE, q, t); q += PRE##_BLKSZ; \ + } \ + \ + /* Done. */ \ + return (0); \ +} \ + \ +/* --- @pre_ocb3tag@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to an OCB3 context \ + * @const pre_ocb3aadctx *aad@ = pointer to AAD context, \ + * or null \ + * @buf *dst@ = buffer for remaining ciphertext \ + * \ + * Returns: Zero on success; @-1@ on failure. \ + * \ + * Use: Common end-of-message handling for encryption and \ + * decryption. The caller is expected to have processed \ + * the last partial block, mixing the padded plaintext \ + * into the checksum and leaving the partial output in \ + * the context's buffer: this function will write the \ + * output to the caller's output buffer. It will compute \ + * the final full-length tag and leave it in the \ + * context's buffer. \ + */ \ + \ +static int pre##_ocb3tag(pre##_ocb3ctx *ctx, \ + const pre##_ocb3aadctx *aad, buf *dst) \ +{ \ + octet *q; \ + \ + /* Arrange space for the final output (if any). */ \ + if (!ctx->off) { q = 0; if (!BOK(dst)) return (-1); } \ + else { q = buf_get(dst, ctx->off); if (!q) return (-1); } \ + \ + /* Deal with whatever's left in the input buffer, if anything */ \ + if (ctx->off) memcpy(q, ctx->b, ctx->off); \ + \ + /* Wrap up the checksum calculation. */ \ + BLKC_XMOVE(PRE, ctx->o, ctx->k.ldollar); \ + BLKC_XMOVE(PRE, ctx->a, ctx->o); \ + pre##_eblk(&ctx->k.ctx, ctx->a, ctx->a); \ + \ + /* Finish off the AAD processing. */ \ + if (aad) { \ + if (aad->i) BLKC_XMOVE(PRE, ctx->a, aad->a); \ + if (aad->off) { \ + memcpy(ctx->b, aad->b, aad->off); \ + ctx->b[aad->off] = 0x80; \ + memset(ctx->b + aad->off + 1, 0, PRE##_BLKSZ - aad->off - 1); \ + BLKC_LOAD(PRE, ctx->o, ctx->b); \ + BLKC_XMOVE(PRE, ctx->o, aad->o); \ + BLKC_XMOVE(PRE, ctx->o, ctx->k.lstar); \ + pre##_eblk(&ctx->k.ctx, ctx->o, ctx->o); \ + BLKC_XMOVE(PRE, ctx->a, ctx->o); \ + } \ + } \ + \ + /* Write the final tag. */ \ + BLKC_STORE(PRE, ctx->b, ctx->a); \ + \ + /* Done. */ \ + return (0); \ +} \ + \ +/* --- @pre_ocb3encryptdone@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to an OCB3 context \ + * @const pre_ocb3aadctx *aad@ = pointer to AAD context, \ + * or null \ + * @buf *dst@ = buffer for remaining ciphertext \ + * @void *tag@ = where to write the tag \ + * @size_t tsz@ = length of tag to store \ + * \ + * Returns: Zero on success; @-1@ on failure. \ + * \ + * Use: Completes an OCB3 encryption operation. The @aad@ \ + * pointer may be null if there is no additional \ + * authenticated data. OCB3 delays output, so this will \ + * cause any remaining buffered plaintext to be encrypted \ + * and written to @dst@. Anyway, the function will fail \ + * if the output buffer is broken. \ + */ \ + \ +int pre##_ocb3encryptdone(pre##_ocb3ctx *ctx, \ + const pre##_ocb3aadctx *aad, buf *dst, \ + void *tag, size_t tsz) \ +{ \ + uint32 t[PRE##_BLKSZ/4], u[PRE##_BLKSZ]; \ + \ + /* Deal with any final partial block. */ \ + if (ctx->off) { \ + BLKC_XMOVE(PRE, ctx->o, ctx->k.lstar); \ + ctx->b[ctx->off] = 0x80; \ + memset(ctx->b + ctx->off + 1, 0, PRE##_BLKSZ - ctx->off - 1); \ + BLKC_LOAD(PRE, t, ctx->b); \ + BLKC_XMOVE(PRE, ctx->a, t); \ + pre##_eblk(&ctx->k.ctx, ctx->o, u); \ + BLKC_XSTORE(PRE, ctx->b, t, u); \ + } \ + \ + /* Return the tag. */ \ + assert(tsz == ctx->tsz); \ + if (pre##_ocb3tag(ctx, aad, dst)) return (-1); \ + memcpy(tag, ctx->b, tsz); \ + return (0); \ +} \ + \ +/* --- @pre_ocb3decryptdone@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to an OCB3 context \ + * @const pre_ocb3aadctx *aad@ = pointer to AAD context, \ + * or null \ + * @buf *dst@ = buffer for remaining plaintext \ + * @const void *tag@ = tag to verify \ + * @size_t tsz@ = length of tag \ + * \ + * Returns: @+1@ for complete success; @0@ if tag verification \ + * failed; @-1@ for other kinds of errors. \ + * \ + * Use: Completes an OCB3 decryption operation. The @aad@ \ + * pointer may be null if there is no additional \ + * authenticated data. OCB3 delays output, so this will \ + * cause any remaining buffered ciphertext to be decrypted \ + * and written to @dst@. Anyway, the function will fail \ + * if the output buffer is broken. \ + */ \ + \ +int pre##_ocb3decryptdone(pre##_ocb3ctx *ctx, \ + const pre##_ocb3aadctx *aad, buf *dst, \ + const void *tag, size_t tsz) \ +{ \ + uint32 t[PRE##_BLKSZ/4], u[PRE##_BLKSZ]; \ + \ + /* Deal with any final partial block. */ \ + if (ctx->off) { \ + BLKC_XMOVE(PRE, ctx->o, ctx->k.lstar); \ + BLKC_LOAD(PRE, t, ctx->b); \ + pre##_eblk(&ctx->k.ctx, ctx->o, u); \ + BLKC_XSTORE(PRE, ctx->b, t, u); \ + ctx->b[ctx->off] = 0x80; \ + memset(ctx->b + ctx->off + 1, 0, PRE##_BLKSZ - ctx->off - 1); \ + BLKC_XLOAD(PRE, ctx->a, ctx->b); \ + } \ + \ + /* Check the tag. */ \ + assert(tsz == ctx->tsz); \ + if (pre##_ocb3tag(ctx, aad, dst)) return (-1); \ + if (ct_memeq(tag, ctx->b, ctx->tsz)) return (+1); \ + else return (0); \ +} \ + \ +/* --- Generic AEAD interface --- */ \ + \ +typedef struct gactx { \ + gaead_aad a; \ + pre##_ocb3aadctx aad; \ +} gactx; \ + \ +static gaead_aad *gadup(const gaead_aad *a) \ + { gactx *aad = S_CREATE(gactx); *aad = *(gactx *)a; return (&aad->a); } \ + \ +static void gahash(gaead_aad *a, const void *h, size_t hsz) \ + { gactx *aad = (gactx *)a; pre##_ocb3aadhash(&aad->aad, h, hsz); } \ + \ +static void gadestroy(gaead_aad *a) \ + { gactx *aad = (gactx *)a; BURN(*aad); S_DESTROY(aad); } \ + \ +static const gaead_aadops gaops = \ + { &pre##_ocb3, gadup, gahash, gadestroy }; \ + \ +static gaead_aad *gaad(const pre##_ocb3key *k) \ +{ \ + gactx *aad = S_CREATE(gactx); \ + aad->a.ops = &gaops; \ + pre##_ocb3aadinit(&aad->aad, k); \ + return (&aad->a); \ +} \ + \ +typedef struct gectx { \ + gaead_enc e; \ + pre##_ocb3ctx ctx; \ +} gectx; \ + \ +static gaead_aad *geaad(gaead_enc *e) \ + { gectx *enc = (gectx *)e; return (gaad(&enc->ctx.k)); } \ + \ +static int gereinit(gaead_enc *e, const void *n, size_t nsz, \ + size_t hsz, size_t msz, size_t tsz) \ +{ \ + gectx *enc = (gectx *)e; \ + return (pre##_ocb3reinit(&enc->ctx, n, nsz, tsz)); \ +} \ + \ +static int geenc(gaead_enc *e, const void *m, size_t msz, buf *b) \ +{ \ + gectx *enc = (gectx *)e; \ + return (pre##_ocb3encrypt(&enc->ctx, m, msz, b)); \ +} \ + \ +static int gedone(gaead_enc *e, const gaead_aad *a, \ + buf *b, void *t, size_t tsz) \ +{ \ + gectx *enc = (gectx *)e; gactx *aad = (gactx *)a; \ + assert(!a || a->ops == &gaops); \ + return (pre##_ocb3encryptdone(&enc->ctx, a ? &aad->aad : 0, b, t, tsz)); \ +} \ + \ +static void gedestroy(gaead_enc *e) \ + { gectx *enc = (gectx *)e; BURN(*enc); S_DESTROY(enc); } \ + \ +static const gaead_encops geops = \ + { &pre##_ocb3, geaad, gereinit, geenc, gedone, gedestroy }; \ + \ +typedef struct gdctx { \ + gaead_dec d; \ + pre##_ocb3ctx ctx; \ +} gdctx; \ + \ +static gaead_aad *gdaad(gaead_dec *d) \ + { gdctx *dec = (gdctx *)d; return (gaad(&dec->ctx.k)); } \ + \ +static int gdreinit(gaead_dec *d, const void *n, size_t nsz, \ + size_t hsz, size_t csz, size_t tsz) \ +{ \ + gdctx *dec = (gdctx *)d; \ + return (pre##_ocb3reinit(&dec->ctx, n, nsz, tsz)); \ +} \ + \ +static int gddec(gaead_dec *d, const void *c, size_t csz, buf *b) \ +{ \ + gdctx *dec = (gdctx *)d; \ + return (pre##_ocb3decrypt(&dec->ctx, c, csz, b)); \ +} \ + \ +static int gddone(gaead_dec *d, const gaead_aad *a, \ + buf *b, const void *t, size_t tsz) \ +{ \ + gdctx *dec = (gdctx *)d; gactx *aad = (gactx *)a; \ + assert(!a || a->ops == &gaops); \ + return (pre##_ocb3decryptdone(&dec->ctx, a ? &aad->aad : 0, b, t, tsz)); \ +} \ + \ +static void gddestroy(gaead_dec *d) \ + { gdctx *dec = (gdctx *)d; BURN(*dec); S_DESTROY(dec); } \ + \ +static const gaead_decops gdops = \ + { &pre##_ocb3, gdaad, gdreinit, gddec, gddone, gddestroy }; \ + \ +typedef struct gkctx { \ + gaead_key k; \ + pre##_ocb3key key; \ +} gkctx; \ + \ +static gaead_aad *gkaad(const gaead_key *k) \ + { gkctx *key = (gkctx *)k; return (gaad(&key->key)); } \ + \ +static gaead_enc *gkenc(const gaead_key *k, const void *n, size_t nsz, \ + size_t hsz, size_t msz, size_t tsz) \ +{ \ + gkctx *key = (gkctx *)k; \ + gectx *enc = S_CREATE(gectx); \ + \ + enc->e.ops = &geops; \ + if (pre##_ocb3init(&enc->ctx, &key->key, n, nsz, tsz)) \ + { gedestroy(&enc->e); return (0); } \ + return (&enc->e); \ +} \ + \ +static gaead_dec *gkdec(const gaead_key *k, const void *n, size_t nsz, \ + size_t hsz, size_t csz, size_t tsz) \ +{ \ + gkctx *key = (gkctx *)k; \ + gdctx *dec = S_CREATE(gdctx); \ + \ + dec->d.ops = &gdops; \ + if (pre##_ocb3init(&dec->ctx, &key->key, n, nsz, tsz)) \ + { gddestroy(&dec->d); return (0); } \ + return (&dec->d); \ +} \ + \ +static void gkdestroy(gaead_key *k) \ + { gkctx *key = (gkctx *)k; BURN(*key); S_DESTROY(key); } \ + \ +static const gaead_keyops gkops = \ + { &pre##_ocb3, gkaad, gkenc, gkdec, gkdestroy }; \ + \ +static gaead_key *gckey(const void *k, size_t ksz) \ +{ \ + gkctx *key = S_CREATE(gkctx); \ + key->k.ops = &gkops; \ + pre##_ocb3setkey(&key->key, k, ksz); \ + return (&key->k); \ +} \ + \ +const gcaead pre##_ocb3 = { \ + name "-ocb3", \ + pre##_keysz, pre##_ocb3noncesz, pre##_ocb3tagsz, \ + PRE##_BLKSZ, PRE##_BLKSZ - 1, 0, AEADF_PCTSZ, \ + gckey \ +}; \ + \ +OCB3_TESTX(PRE, pre, name, fname) + +/*----- Test rig ----------------------------------------------------------*/ + +#define OCB3_TEST(PRE, pre) OCB3_TESTX(PRE, pre, #pre, #pre) + +/* --- @OCB3_TEST@ --- * + * + * Arguments: @PRE, pre@ = prefixes for the underlying block cipher + * + * Use: Standard test rig for OCB3 functions. + */ + +#ifdef TEST_RIG + +#include + +#include +#include +#include + +#define OCB3_TESTX(PRE, pre, name, fname) \ + \ +static int ocb3verify(dstr *v) \ +{ \ + pre##_ocb3key key; \ + pre##_ocb3aadctx aad; \ + pre##_ocb3ctx ctx; \ + int ok = 1, win; \ + int i; \ + octet *p; \ + int szs[] = { 1, 7, 192, -1, 0 }, *ip; \ + size_t hsz, msz; \ + dstr d = DSTR_INIT, t = DSTR_INIT; \ + buf b; \ + \ + dstr_ensure(&d, v[4].len > v[3].len ? v[4].len : v[3].len); \ + dstr_ensure(&t, v[5].len); t.len = v[5].len; \ + \ + pre##_ocb3setkey(&key, v[0].buf, v[0].len); \ + \ + for (ip = szs; *ip; ip++) { \ + \ + pre##_ocb3init(&ctx, &key, (octet *)v[1].buf, v[1].len, v[5].len); \ + \ + i = *ip; \ + hsz = v[2].len; \ + if (i == -1) i = hsz; \ + if (i > hsz) continue; \ + p = (octet *)v[2].buf; \ + pre##_ocb3aadinit(&aad, &key); \ + while (hsz) { \ + if (i > hsz) i = hsz; \ + pre##_ocb3aadhash(&aad, p, i); \ + p += i; hsz -= i; \ + } \ + \ + buf_init(&b, d.buf, d.sz); \ + i = *ip; \ + msz = v[3].len; \ + if (i == -1) i = msz; \ + if (i > msz) continue; \ + p = (octet *)v[3].buf; \ + while (msz) { \ + if (i > msz) i = msz; \ + if (pre##_ocb3encrypt(&ctx, p, i, &b)) { \ + puts("!! ocb3encrypt reports failure"); \ + goto fail_enc; \ + } \ + p += i; msz -= i; \ + } \ + \ + if (pre##_ocb3encryptdone(&ctx, &aad, &b, (octet *)t.buf, t.len)) { \ + puts("!! ocb3encryptdone reports failure"); \ + goto fail_enc; \ + } \ + d.len = BLEN(&b); \ + \ + if (d.len != v[4].len || \ + memcmp(d.buf, v[4].buf, v[4].len) != 0 || \ + memcmp(t.buf, v[5].buf, v[5].len) != 0) { \ + fail_enc: \ + printf("\nfail encrypt:\n\tstep = %i", *ip); \ + fputs("\n\tkey = ", stdout); type_hex.dump(&v[0], stdout); \ + fputs("\n\tnonce = ", stdout); type_hex.dump(&v[1], stdout); \ + fputs("\n\theader = ", stdout); type_hex.dump(&v[2], stdout); \ + fputs("\n\tmessage = ", stdout); type_hex.dump(&v[3], stdout); \ + fputs("\n\texp ct = ", stdout); type_hex.dump(&v[4], stdout); \ + fputs("\n\tcalc ct = ", stdout); type_hex.dump(&d, stdout); \ + fputs("\n\texp tag = ", stdout); type_hex.dump(&v[5], stdout); \ + fputs("\n\tcalc tag = ", stdout); type_hex.dump(&t, stdout); \ + putchar('\n'); \ + ok = 0; \ + } \ + \ + pre##_ocb3init(&ctx, &key, (octet *)v[1].buf, v[1].len, v[5].len); \ + \ + buf_init(&b, d.buf, d.sz); \ + i = *ip; \ + msz = v[4].len; \ + if (i == -1) i = msz; \ + if (i > msz) continue; \ + p = (octet *)v[4].buf; \ + while (msz) { \ + if (i > msz) i = msz; \ + if (pre##_ocb3decrypt(&ctx, p, i, &b)) { \ + puts("!! ocb3decrypt reports failure"); \ + win = 0; goto fail_dec; \ + } \ + p += i; msz -= i; \ + } \ + \ + win = pre##_ocb3decryptdone(&ctx, &aad, &b, \ + (octet *)v[5].buf, v[5].len); \ + if (win < 0) { \ + puts("!! ocb3decryptdone reports failure"); \ + goto fail_dec; \ + } \ + d.len = BLEN(&b); \ + \ + if (d.len != v[3].len || !win || \ + memcmp(d.buf, v[3].buf, v[3].len) != 0) { \ + fail_dec: \ + printf("\nfail decrypt:\n\tstep = %i", *ip); \ + fputs("\n\tkey = ", stdout); type_hex.dump(&v[0], stdout); \ + fputs("\n\tnonce = ", stdout); type_hex.dump(&v[1], stdout); \ + fputs("\n\theader = ", stdout); type_hex.dump(&v[2], stdout); \ + fputs("\n\tciphertext = ", stdout); type_hex.dump(&v[4], stdout); \ + fputs("\n\texp pt = ", stdout); type_hex.dump(&v[3], stdout); \ + fputs("\n\tcalc pt = ", stdout); type_hex.dump(&d, stdout); \ + fputs("\n\ttag = ", stdout); type_hex.dump(&v[5], stdout); \ + printf("\n\tverify %s", win ? "ok" : "FAILED"); \ + putchar('\n'); \ + ok = 0; \ + } \ + } \ + \ + dstr_destroy(&d); dstr_destroy(&t); \ + return (ok); \ +} \ + \ +static int ocb3mct(dstr *v) \ +{ \ + unsigned ksz = *(unsigned long *)v[0].buf, tsz = v[1].len; \ + dstr d = DSTR_INIT; \ + octet z[128]; \ + pre##_ocb3key k; \ + pre##_ocb3ctx ctx; \ + pre##_ocb3aadctx oaad, iaad; \ + int rc; \ + buf b; \ + unsigned i; \ + int ok = 1; \ + \ + dstr_ensure(&d, ksz); memset(d.buf, 0, ksz - 4); \ + STORE32_B(d.buf + ksz - 4, 8*tsz); \ + pre##_ocb3setkey(&k, d.buf, ksz); \ + \ + pre##_ocb3aadinit(&oaad, &k); \ + \ + dstr_ensure(&d, 128 + tsz); \ + memset(z, 0, 128); \ + pre##_ocb3init(&ctx, &k, z, PRE##_BLKSZ - 4, tsz); \ + \ + for (i = 0; i < 128; i++) { \ + pre##_ocb3aadinit(&iaad, &k); pre##_ocb3aadhash(&iaad, z, i); \ + \ + pre##_ocb3step(&ctx); buf_init(&b, d.buf, i); \ + rc = pre##_ocb3encrypt(&ctx, z, i, &b); if (rc) goto fail; \ + rc = pre##_ocb3encryptdone(&ctx, &iaad, &b, d.buf + i, tsz); \ + if (rc) goto fail; \ + pre##_ocb3aadhash(&oaad, d.buf, i + tsz); \ + \ + pre##_ocb3step(&ctx); buf_init(&b, d.buf, i); \ + rc = pre##_ocb3encrypt(&ctx, z, i, &b); if (rc) goto fail; \ + rc = pre##_ocb3encryptdone(&ctx, 0, &b, d.buf + i, tsz); \ + if (rc) goto fail; \ + pre##_ocb3aadhash(&oaad, d.buf, i + tsz); \ + \ + pre##_ocb3step(&ctx); buf_init(&b, 0, 0); \ + rc = pre##_ocb3encryptdone(&ctx, &iaad, &b, d.buf, tsz); \ + if (rc) goto fail; \ + pre##_ocb3aadhash(&oaad, d.buf, tsz); \ + } \ + \ + pre##_ocb3step(&ctx); buf_init(&b, 0, 0); \ + rc = pre##_ocb3encryptdone(&ctx, &oaad, &b, d.buf, tsz); \ + if (rc) goto fail; \ + \ + d.len = tsz; \ + if (memcmp(d.buf, v[1].buf, tsz) != 0) { \ + fail: \ + printf("\nfail mct: ksz = %u, tsz = %u", ksz, tsz); \ + fputs("\n\texp tag = ", stdout); type_hex.dump(&v[1], stdout); \ + fputs("\n\tcalc tag = ", stdout); type_hex.dump(&d, stdout); \ + putchar('\n'); \ + ok = 0; \ + } \ + \ + return (ok); \ +} \ + \ +static test_chunk aeaddefs[] = { \ + { name "-ocb3", ocb3verify, \ + { &type_hex, &type_hex, &type_hex, &type_hex, \ + &type_hex, &type_hex, 0 } }, \ + { name "-ocb3-mct", ocb3mct, \ + { &type_ulong, &type_hex, 0 } }, \ + { 0, 0, { 0 } } \ +}; \ + \ +int main(int argc, char *argv[]) \ +{ \ + ego(argv[0]); \ + test_run(argc, argv, aeaddefs, SRCDIR"/t/" fname); \ + return (0); \ +} + +#else +# define OCB3_TESTX(PRE, pre, name, fname) +#endif + +/*----- That's all, folks -------------------------------------------------*/ + +#ifdef __cplusplus + } +#endif + +#endif diff --git a/symm/ocb3.h b/symm/ocb3.h new file mode 100644 index 00000000..ceb2df02 --- /dev/null +++ b/symm/ocb3.h @@ -0,0 +1,337 @@ +/* -*-c-*- + * + * The OCB3 authenticated encryption mode + * + * (c) 2018 Straylight/Edgeware + */ + +/*----- Licensing notice --------------------------------------------------* + * + * This file is part of Catacomb. + * + * Catacomb is free software: you can redistribute it and/or modify it + * under the terms of the GNU Library General Public License as published + * by the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * Catacomb is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with Catacomb. If not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +/*----- Notes on OCB3 -----------------------------------------------------* + * + * OCB3 was designed in 2011 by Phillip Rogaway and Ted Krovetz, building ten + * years of earlier work by Rogaway, Bellare, and Black, and refining Jutla's + * pioneering work on IACBC and IAPM. OCB3 is an efficient `authenticated + * encryption with associated data' (AEAD) scheme which requires only one + * blockcipher application per message block. + * + * The patent situation on these efficient authenticated encryption schemes + * is fraught. IBM hold two patents on Jutla's pioneering work on `IACBC' + * and `IAPM' which can apply (a third was filed at least six years too + * late), and Virgil Gligor and Pompiliu Donescu hold patents on their `XECB' + * and `XCBC' modes; these may or may not apply to OCB. Rogaway himself + * holds US patents on various versions of OCB, but has issued free licences + * for free (`open source') software, and for all non-military use. I think + * Catacomb's implementation of OCB falls within the scope of the former + * licence. + * + * OCB3 has optimized for short messages with `similar' nonces, where + * `similar' means `all but the low bits in the last byte are equal'; exactly + * how many bits depends on the block length in a rather complicated manner. + * This implementation supports this optimization through @pre_ocb3reinit@ + * (which compares the new nonce against the old one to see whether it can + * make use of the similarity), and, more directly, through @pre_ocb3step@, + * which (effectively) advances the nonce as a big-endian counter. + * + * OCB3 was originally defined only for 128-bit blockciphers, and extending + * it to other sizes is nontrivial, but this has been done by Ted Krovetz in + * I-D draft-krovetz-ocb-wideblock-00 (following initial prompting from, err, + * me). + * + * OCB3 is a fairly well-behaved AEAD mode. It doesn't require + * precommentment to the header or message lengths, but does require + * precommitment to the tag length. It permits header data to be processed + * independently of any message. It only accepts nonces the same size as the + * underlying blockcipher's block size, and it buffers up to a whole block's + * worth of data internally, which somewhat complicates streaming. + */ + +#ifndef CATACOMB_OCB3_H +#define CATACOMB_OCB3_H + +#ifdef __cplusplus + extern "C" { +#endif + +/*----- Header files ------------------------------------------------------*/ + +#include + +#include +#include + +#ifndef CATACOMB_GAEAD_H +# include "gaead.h" +#endif + +#ifndef CATACOMB_OCB_H +# include "ocb.h" +#endif + +/*----- Macros ------------------------------------------------------------*/ + +/* --- @OCB3_DECL@ --- * + * + * Arguments: @PRE@, @pre@ = prefixes for the underlying block cipher + * + * Use: Creates declarations for OCB3 message-authentication mode. + */ + +#define OCB3_NSZMAX(PRE) (PRE##_BLKSZ - (PRE##_BLKSZ <= 16 ? 1 : 2)) + +#define OCB3_DECL(PRE, pre) \ + \ +typedef struct pre##_ocb3key { \ + pre##_ctx ctx; /* Underlying cipher context */ \ + uint32 lstar[PRE##_BLKSZ/4]; /* Partial-block mask */ \ + uint32 ldollar[PRE##_BLKSZ/4]; /* Checksum mask */ \ + uint32 lmask[OCB_NCALC][PRE##_BLKSZ/4]; /* Precalculated masks */ \ +} pre##_ocb3key; \ + \ +typedef struct pre##_ocb3aadctx { \ + pre##_ocb3key k; /* Processed key material */ \ + uint32 o[PRE##_BLKSZ/4]; /* Current offset */ \ + uint32 a[PRE##_BLKSZ/4]; /* Accumulator state */ \ + octet b[PRE##_BLKSZ]; /* Input buffer */ \ + unsigned long i; /* Block counter */ \ + unsigned off; /* Offset into buffered data */ \ +} pre##_ocb3aadctx; \ + \ +typedef struct pre##_ocb3ctx { \ + pre##_ocb3key k; /* Processed key material */ \ + unsigned nix, tsz; /* Nonce index and tag size */ \ + uint32 nbase[PRE##_BLKSZ/2]; /* Current base nonce */ \ + uint32 nstretch[PRE##_BLKSZ/2]; /* Stretched nonce material */ \ + uint32 o[PRE##_BLKSZ/4]; /* Current offset */ \ + uint32 a[PRE##_BLKSZ/4]; /* Accumulator state */ \ + octet b[PRE##_BLKSZ]; /* Input buffer */ \ + unsigned long i; /* Block counter */ \ + unsigned off; /* Offset into buffered data */ \ +} pre##_ocb3ctx; \ + \ +extern const octet pre##_ocb3noncesz[], pre##_ocb3tagsz[]; \ + \ +/* --- @pre_ocb3setkey@ --- * \ + * \ + * Arguments: @pre_ocb3key *key@ = pointer to key block to fill in \ + * @const void *k@ = pointer to key material \ + * @size_t ksz@ = size of key material \ + * \ + * Returns: --- \ + * \ + * Use: Initializes an OCB3 key block. \ + */ \ + \ +extern void pre##_ocb3setkey(pre##_ocb3key */*key*/, \ + const void */*k*/, size_t /*ksz*/); \ + \ +/* --- @pre_ocb3aadinit@ --- * \ + * \ + * Arguments: @pre_ocb3aadctx *aad@ = pointer to AAD context \ + * @const pre_ocb3key *key@ = pointer to key block \ + * \ + * Returns: --- \ + * \ + * Use: Initializes an OCB3 AAD (`additional authenticated \ + * data') context associated with a given key. AAD \ + * contexts can be copied and/or reused, saving time if \ + * the AAD for number of messages has a common prefix. \ + * \ + * The @key@ doesn't need to be kept around, though \ + * usually there'll at least be another copy in some OCB3 \ + * operation context because the AAD on its own isn't much \ + * good. \ + */ \ + \ +extern void pre##_ocb3aadinit(pre##_ocb3aadctx */*aad*/, \ + const pre##_ocb3key */*key*/); \ + \ +/* --- @pre_ocb3aadhash@ --- * \ + * \ + * Arguments: @pre_ocb3aadctx *aad@ = pointer to AAD context \ + * @const void *p@ = pointer to AAD material \ + * @size_t sz@ = length of AAD material \ + * \ + * Returns: --- \ + * \ + * Use: Feeds AAD into the context. \ + */ \ + \ +extern void pre##_ocb3aadhash(pre##_ocb3aadctx */*aad*/, \ + const void */*p*/, size_t /*sz*/); \ + \ +/* --- @pre_ocb3init@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to OCB3 context \ + * @const pre_ocb3key *key@ = pointer to key block \ + * @const void *n@ = pointer to nonce \ + * @size_t nsz@ = size of nonce \ + * @size_t tsz@ = tag length \ + * \ + * Returns: Zero on success, @-1@ if the nonce or tag length is \ + * bad. \ + * \ + * Use: Initialize an OCB3 operation context with a given key. \ + * \ + * The original key needn't be kept around any more. \ + */ \ + \ +extern int pre##_ocb3init(pre##_ocb3ctx */*ctx*/, \ + const pre##_ocb3key */*k*/, \ + const void */*n*/, size_t /*nsz*/, \ + size_t /*tsz*/); \ + \ +/* --- @pre_ocb3reinit@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to OCB3 context \ + * @const void *n@ = pointer to nonce \ + * @size_t nsz@ = size of nonce \ + * @size_t tsz@ = tag length \ + * \ + * Returns: Zero on success, @-1@ if the nonce or tag length is \ + * bad. \ + * \ + * Use: Reinitialize an OCB3 operation context, changing the \ + * nonce and/or tag length. \ + */ \ + \ +extern int pre##_ocb3reinit(pre##_ocb3ctx */*ctx*/, \ + const void */*n*/, size_t /*nsz*/, \ + size_t /*tsz*/); \ + \ +/* --- @pre_ocb3step@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to OCB3 context \ + * \ + * Returns: --- \ + * \ + * Use: Reinitialize an OCB3 operation context, stepping to \ + * the `next' nonce along. \ + */ \ + \ +extern void pre##_ocb3step(pre##_ocb3ctx */*ctx*/); \ + \ +/* --- @pre_ocb3encrypt@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to OCB3 operation context \ + * @const void *src@ = pointer to plaintext message chunk \ + * @size_t sz@ = size of the plaintext \ + * @buf *dst@ = a buffer to write the ciphertext to \ + * \ + * Returns: Zero on success; @-1@ on failure. \ + * \ + * Use: Encrypts a chunk of a plaintext message, writing a \ + * chunk of ciphertext to the output buffer and updating \ + * the operation state. \ + * \ + * Note that OCB3 delays output if its input is not a \ + * whole number of blocks. This means that the output \ + * might be smaller or larger the input by up to the block \ + * size. \ + */ \ + \ +extern int pre##_ocb3encrypt(pre##_ocb3ctx */*ctx*/, \ + const void */*src*/, size_t /*sz*/, \ + buf */*dst*/); \ + \ +/* --- @pre_ocb3decrypt@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to OCB3 operation context \ + * @const void *src@ = pointer to ciphertext message chunk \ + * @size_t sz@ = size of the ciphertext \ + * @buf *dst@ = a buffer to write the plaintext to \ + * \ + * Returns: Zero on success; @-1@ on failure. \ + * \ + * Use: Decrypts a chunk of a ciphertext message, writing a \ + * chunk of plaintext to the output buffer and updating \ + * the operation state. \ + * \ + * Note that OCB3 delays output if its input is not a \ + * whole number of blocks. This means that the output \ + * might be smaller or larger the input by up to the block \ + * size. \ + */ \ + \ +extern int pre##_ocb3decrypt(pre##_ocb3ctx */*ctx*/, \ + const void */*src*/, size_t /*sz*/, \ + buf */*dst*/); \ + \ +/* --- @pre_ocb3encryptdone@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to an OCB3 context \ + * @const pre_ocb3aadctx *aad@ = pointer to AAD context, \ + * or null \ + * @buf *dst@ = buffer for remaining ciphertext \ + * @void *tag@ = where to write the tag \ + * @size_t tsz@ = length of tag to store \ + * \ + * Returns: Zero on success; @-1@ on failure. \ + * \ + * Use: Completes an OCB3 encryption operation. The @aad@ \ + * pointer may be null if there is no additional \ + * authenticated data. OCB3 delays output, so this will \ + * cause any remaining buffered plaintext to be encrypted \ + * and written to @dst@. Anyway, the function will fail \ + * if the output buffer is broken. \ + */ \ + \ +extern int pre##_ocb3encryptdone(pre##_ocb3ctx */*ctx*/, \ + const pre##_ocb3aadctx */*aad*/, \ + buf */*dst*/, \ + void */*tag*/, size_t /*tsz*/); \ + \ +/* --- @pre_ocb3decryptdone@ --- * \ + * \ + * Arguments: @pre_ocb3ctx *ctx@ = pointer to an OCB3 context \ + * @const pre_ocb3aadctx *aad@ = pointer to AAD context, \ + * or null \ + * @buf *dst@ = buffer for remaining plaintext \ + * @const void *tag@ = tag to verify \ + * @size_t tsz@ = length of tag \ + * \ + * Returns: @+1@ for complete success; @0@ if tag verification \ + * failed; @-1@ for other kinds of errors. \ + * \ + * Use: Completes an OCB3 decryption operation. The @aad@ \ + * pointer may be null if there is no additional \ + * authenticated data. OCB3 delays output, so this will \ + * cause any remaining buffered ciphertext to be decrypted \ + * and written to @dst@. Anyway, the function will fail \ + * if the output buffer is broken. \ + */ \ + \ +extern int pre##_ocb3decryptdone(pre##_ocb3ctx */*ctx*/, \ + const pre##_ocb3aadctx */*aad*/, \ + buf */*dst*/, \ + const void */*tag*/, size_t /*tsz*/); \ + \ +/* --- Generic AEAD interface --- */ \ + \ +extern const gcaead pre##_ocb3; + +/*----- That's all, folks -------------------------------------------------*/ + +#ifdef __cplusplus + } +#endif + +#endif diff --git a/symm/t/blowfish b/symm/t/blowfish index 778a7f2b..a49688c2 100644 --- a/symm/t/blowfish +++ b/symm/t/blowfish @@ -831,3 +831,219 @@ blowfish-pmac1 { bdff3bcd211499268878dbf30f1dad89d4b9b1 e193575442a800ab; } + +blowfish-ocb3 { + 60d7bcda163547d348b7551195e77022907dd1dff7dac5c9941d26d0c6eb14ad568f86edd1dc9268eeee533285a6ed810c9b689daaa906 + 0d2d4b600306 + "" + "" + "" + b3583d3de56211f4; + 2365b0a54364c76c160f11896c4794846ecfa14a7130c9f137120634c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f29549e + 6b0d27a4ba23 + 40 + "" + "" + 912c60b4f34b6731; + 85406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e6057acc87638f508046733d9 + ff61cdbda3b3 + "" + e9 + dd + 49ef753d0e5893dc; + 878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9 + b2fc5f + "" + a450727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3 + 104cef2c140c06f2a9c502bd63c02be3d940a76e94b52e8e + 2279d2765293b605; + ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93bf4f2aad2605faee2b03fb648e27fff63102758fe2b69ac + 26afa33498 + 29b94586306fed54154f8f28523c03d4de1600157846b710 + ee72807a2219bfb474fd71d891f24bb65d1563259f9eb53b + e2f8d8fe5551cca9b88351ee9e422ceb2ed4abfaca8fa2b8 + 4cce00e139bd21d6; + 571ea629c54d57dd2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f768281e040a9b9a2 + 22bd689aef66 + "" + f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d + e4fddb14c2c34d5695f13bdc9e21f6ff4605c864e2e7b0550606d5f478 + c07b9776137a4225; + 95214ade49cb3b6f5fe8368131115c037ba323fe1dc8151784873f0eb5b647da6794c18b5337685a96ed65b9aca338527ef19b09c063c4 + 6f88de9fd41e + 72d7b97e23e6eabdff3bcd211499268878dbf3 + 0f1dad89d4b9b12012e4713df46795630e7952d22bb02d7100b8b64937 + c64055e9e272881679259cd8f6d67f2291cea67a6865f4af686f02f032 + 32eace6f457de00d; + 7d20a8f083455b663e4ee1 + 315f3c8f2aeb + "" + "" + "" + 99933637fa8f2b85; + fa921451dcd1af5813b70d + 30ce2f1fef6e + f3 + "" + "" + b6e8c9c6a45b2a56; + 15d0798391805da08da3ae + fc5f8584b7c5 + "" + e6 + 80 + 3facc6b40f6e5187; + 17669c0f16e39815d4e9cf + ce3ed1 + "" + ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c31e6 + 859387df0c8d6efe243bba8c894f17fa1935f42cd6148235 + 4d1dd56b61f0988b; + bc58c0b7cadcb658b970e4 + 7479a684b5 + aefa69a4cd52147ed12ca986981a874498ad0abef8bc4fcb + 70e27e98ef1f0446b42fb144d44b6d00f06dc188d472a784 + ebf8c0ff4e24b5754891cff817c499efa87b8a9fdf0d2cc1 + 1d3775fe8dc794e7; + e0c6f21195a3b9f4ae9855 + 11265febd11c + "" + 164720eef9eb1c8dd0b00951f284649016ed00456331854bc78bf43966 + cc19d5c325f9e65a669dc5e47d9ebfc15d3a3f609d8a96bf9d6eb710fa + dba9d363c65b7e0b; + eb0cfa9138ddc399084456 + 08fe95e81c25 + 33e31c9c1a9851bc2810d858cbbc8424d126b8 + 07e6daa089c3f9099c5ffb824173d7634c04226f30cbb7f0e4a973a8cd + 53fd73e769e423e95ea852b9f025096cff34e3d1902ff701cdf24790c8 + eb3ca419114e51fe; + 1901073147 + 17a77456f3ff + "" + "" + "" + be3a587aad834d02; + 669c732b58 + db8f48af65f7 + cc + "" + "" + 2d749c7591283c5c; + 9e3fb90e17 + 21b730374ffc + "" + 9b + 43 + 0e0346447f445eca; + c597f56ccb + b2f294 + "" + b38766fc69f6a9f2c0945ffd505003cc0cae9ce021a5f1fa + 06da8393393846121625c231930a8490f2a4ce8b89447e2b + 78e64ea8e4df5f24; + 4ffa915444 + 85f1a1258b + 2b9b8f0911e32d65cc1770a18cbfe6effd1ff6778554acf1 + 270485b203a3c1c4c967c0a458cb948bdd409b687fa3a682 + 8f7152ef08106003140fd22ae1d7911123b04337f8e2cff6 + c3c1d8284b448b74; + 7b480aa3a4 + c84cef64f6c9 + "" + b53bf8f957f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd20 + d0d64b53c566f1dc431a72dda89c51a7b7d25a57638af924b7f56d75e7 + c691e0e094254334; + 5b70e04c09 + 1d205cdad9e9 + a79b1abf91b0851e5ca605ac84513995870116 + 77508a15dde524af3e2bee0646541a42c2ecccb44d65bad397abfaf529 + b930562d3cc00abaeaa1dc8ff5825cdf086e0ba72916c06d9bd4f837bd + 90343080f7fb1dda; + ee41cf9a05c7efedef3401539c51d2a90bbf7f1bfc338a + b0ef5746ea8f + "" + "" + "" + 91f6852537252f8a; + dcccd213e33f7e8a5718fd25014107c8e7d715a92add95 + 89d1f5c054b2 + d9 + "" + "" + b36663b6367ef6ef; + 83514605ec590294a319b9802068a9f891bc5ba5afabf8 + c3122d12d7ff + "" + 3c + e5 + 1961c689d2d77714; + 41122d70d17d4569eaff59a332ba58d5d5589bfe079753 + ee1a95 + "" + 7eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7 + cb0853f95fc84b810db7f3b9518d6c1a1ef5e78a3d316746 + 5b65e59ea9a723f0; + abc8ad68daac90cfe22d2f1f2968cc42fa8b669ed3bb35 + 42a9cf44bb + c8c6254d980398bd94e66eb4563d405e51881e99027b8ab9 + aea3ccf860b0009740763d96836c5f87b95460938de1288c + fbd80f2a162c319b91c99ed4a0f8860cbad42c59792cf7ac + 35dac492225424a6; + 69d80ea12ff4bb5f069b8a2e86041c1b9fc214e9ca2186 + ddf1f6a7a3aa + "" + 7e740da967828e3604b35b15ffaa6c36800d9645563a308ba600768175 + 75bef1ae59a3404b09299f06461e0cbb3a9d6e58d4f49928f9b0845f01 + f93d21e578e90e18; + 23bd2abf1261b089d8f23a9c2835076a23faac2cdd6777 + 1cc667a8331f + 0a170b66283e4f834a06148f302c3973accd56 + f6f24e33958b8c2e2352fd61e4fa8fec816ac861a8b33779f09e7a10fc + 6128d1bdba407d841d26fb849b2f1967f1877822a75c402b845bd5f1b1 + 2951dd60e7a50fe4; +} + +blowfish-ocb3-mct { + 56 1eaefdb48ac7e8be; + 52 b79553ab012d6259; + 48 e596561501cbb1d1; + 44 0b3d0dd4007cc8e1; + 40 5e01c4481579151f; + 36 f745536adb730368; + 32 261481ed1915729e; + 28 b6fa034db1ed80e8; + 24 0b7aed4db823ce0c; + 20 472a7cbbc3b93999; + 16 4434cb1c40f21097; + 12 4f64439b9bcedfc2; + 10 654a7c2699f7e4db; + 8 b0d1574724b61c02; + 56 883bad05122a; + 52 1cf7ba9a0e86; + 48 44d9c92bfb48; + 44 2ab05efeab38; + 40 fb1788302233; + 36 926b61ed2153; + 32 d240e2d8b6e9; + 28 6a7452bc8c50; + 24 7be498392971; + 20 90d3cb1c76c2; + 16 a4ce66e48d8f; + 12 15a879e95625; + 10 2af8e886f690; + 8 c3ecbf857159; + 56 f196b27c; + 52 84c6f8e6; + 48 2323c6f4; + 44 c3c03f9d; + 40 57979457; + 36 318c4335; + 32 1928bd41; + 28 cb2429ec; + 24 369cdefd; + 20 45e7c011; + 16 32768164; + 12 469cab17; + 10 17a3dd1d; + 8 a4a15a19; +} diff --git a/symm/t/cast128 b/symm/t/cast128 index e871e0c4..7ea4b47d 100644 --- a/symm/t/cast128 +++ b/symm/t/cast128 @@ -727,3 +727,198 @@ cast128-pmac1 { ff63102758fe2b69ac26afa3349829b9458630 cab1db46326dab8b; } + +cast128-ocb3 { + 60d7bcda163547d348b7551195 + e77022907dd1 + "" + "" + "" + 80acf79035879e49; + dff7dac5c9941d26d0c6eb14ad + 568f86edd1dc + 92 + "" + "" + c1c0b7cf9333abd0; + 68eeee533285a6ed810c9b689d + aaa9060d2d4b + "" + 60 + b7 + 2ba34997b9b7c1e7; + 03062365b0a54364c76c160f11 + 896c47 + "" + 94846ecfa14a7130c9f137120634c9519848a877ff77bf79 + a50349e70f84c21e91ac4dae8e84334c4eded066c4906f46 + 044e9f72b51e120b; + 192a5b50ade5d9cd739a3d1f33 + 7f29549e6b + 0d27a4ba234085406a6136512061f7080cc07df0591d8fa2 + 1f2dd88374d8cde8e160ad10997a21635c6d62c9269029df + ff3c222bcd45bd08ed535a77e89023455b21fd6b198e5220 + 6078eab50bffcabf; + 3e6057acc87638f508046733d9 + ff61cdbda3b3 + "" + e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a89447 + c9cff5648431ab446232a4644f1c59af90abdc696868521a9632a765af + e993a7f8297d83bd; + 6b3f102b752eb9529533966f27 + 043eb621b7f6 + 5b000961040ef2f9b2fc5fa450727a9b542cde + 52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c + d94512471232da2099eee100523fb16bb45018f05f681f067aaf7af8d6 + 87dca8c2d5779501; + 33d090c54215ab + d6b3ad54efc9 + "" + "" + "" + da927642dafe6fd1; + a38378c5b93bf4 + f2aad2605fae + e2 + "" + "" + e890bed519c2bfc9; + b03fb648e27fff + 63102758fe2b + "" + 69 + f6 + a1e73f23ec2eddee; + ac26afa3349829 + b94586 + "" + 306fed54154f8f28523c03d4de1600157846b710ee72807a + 0cf707f93f9c389e7c78ef3e61d36d20604e1441b169fc9a + 6febc37ff410bc6f; + 2219bfb474fd71 + d891f24bb6 + 5d1563259f9eb53b571ea629c54d57dd2d42f70800df9fcb + aca48b77dba189196d1ebba10b0467cb9fc2712a199e533f + 06e300b114e2b4bebe212cf694364bc44989b8cfe139b08a + b496b69d5f5f2406; + a9156308cdec3f + 768281e040a9 + "" + b9a222bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb23 + 0af7dab55d9223c86960d4b03e62b32f96a5c1ee581be399c93b15e789 + 97f72d7c401cf252; + 3bfa6a5cfb0bad + 7d95214ade49 + cb3b6f5fe8368131115c037ba323fe1dc81517 + 84873f0eb5b647da6794c18b5337685a96ed65b9aca338527ef19b09c0 + a0f7f9f1e1934502280dfa21be7bd3eadab7541c17cccc03102dcb3454 + 22cc4588498bc2a5; + 63c46f88de9fd41e72d7 + b97e23e6eabd + "" + "" + "" + 869d689f3cb451ab; + ff3bcd211499268878db + f30f1dad89d4 + b9 + "" + "" + 10c4ca311ab0d4ea; + b12012e4713df4679563 + 0e7952d22bb0 + "" + 2d + ae + d91ecbfa408ed62c; + 7100b8b649377d20a8f0 + 83455b + "" + 663e4ee1315f3c8f2aebfa921451dcd1af5813b70d30ce2f + 447474323cef334fa9a0733f9dcca98a6f5f79b395392cea + 9b75ce84a39e878e; + 1fef6ef315d079839180 + 5da08da3ae + fc5f8584b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d + 264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0 + 4e006eb2b0cb5e16f592ac6c5601c80e7a97fb0725c1ca4f + adcac831efd97e58; + b7cadcb658b970e47479 + a684b5aefa69 + "" + a4cd52147ed12ca986981a874498ad0abef8bc4fcb70e27e98ef1f0446 + 9f8a879d391e2c63103be599717c39608d4f0d42ab0b17bb3515e1e210 + d2579224689f1c51; + b42fb144d44b6d00f06d + c188d472a784 + e0c6f21195a3b9f4ae985511265febd11c1647 + 20eef9eb1c8dd0b00951f284649016ed00456331854bc78bf43966eb0c + 87e39284c048d9c1660e5437f1cc86615724448c5c86d185b1a54bc05c + 52b0cf04002f103f; + fa9138ddc399084456 + 08fe95e81c25 + "" + "" + "" + 08923b4787ecca64; + 33e31c9c1a9851bc28 + 10d858cbbc84 + 24 + "" + "" + 9c2d888635429e4f; + d126b807e6daa089c3 + f9099c5ffb82 + "" + 41 + 76 + 14aedb991bbdf5d5; + 73d7634c04226f30cb + b7f0e4 + "" + a973a8cd190107314717a77456f3ff669c732b58db8f48af + ec093b797db58fa9c9b88e58ffbde6f4f4c38fb6db25b117 + 3eeb6753ae39c984; + 65f7cc9e3fb90e1721 + b730374ffc + 9bc597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003 + cc0cae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f0911 + 3ffec2f705cc006637248de55ef480c9401790a303ccd564 + 6d3b369a0699bf98; + e32d65cc1770a18cbf + e6effd1ff677 + "" + 8554acf1270485b203a3c1c4c967c0a458cb948bdd409b687fa3a6827b + 91e2b0612406d31b88b044f838e29dc4bc08492a9d8b73b1751f6eb210 + d684fc47c7b172f0; + 480aa3a4c84cef64f6 + c9b53bf8f957 + f4b03cf43e89957f9a3e8128f8743d16687b7b + b8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605ac84 + f9bc629deb9e6dc3454415296389546e992975ef5c6dfba23357c06539 + d4d1265b9cad7cee; +} + +cast128-ocb3-mct { + 16 d2434caa22748e97; + 14 4dab36316a173b4c; + 12 25b37d39f09b8f7b; + 10 6ea2b818da01a012; + 8 e4e0aa59657d2246; + 6 29299e3845bdedad; + 4 99594416fa91c2f7; + 16 460ffc3b13c9; + 14 ff7bc7e6be51; + 12 e0a21b1ff4b7; + 10 5062cd9b7b51; + 8 5d40437352df; + 6 22a0f6279d79; + 4 429d09c799fc; + 16 a42ad529; + 14 9dec6cc9; + 12 15803553; + 10 5c50c831; + 8 4a2e5743; + 6 e10bbd1e; + 4 4a6bf7e7; +} diff --git a/symm/t/cast256.local b/symm/t/cast256.local index c2d6067e..a52ad886 100644 --- a/symm/t/cast256.local +++ b/symm/t/cast256.local @@ -689,3 +689,204 @@ cast256-pmac1 { 1e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89d4b9b12012e4713df46795630e7952d22bb02d 37e48b490fc5476f6a317210987af58c; } + +cast256-ocb3 { + 60d7bcda163547d348b7551195 + e77022907dd1dff7dac5c9941d26 + "" + "" + "" + 5d4fdb3278da8699e7a297755690b588; + d0c6eb14ad568f86edd1dc9268 + eeee533285a6ed810c9b689daaa9 + 06 + "" + "" + fd23cef36d5d13dfbbc3f91a2edcbed2; + 0d2d4b6003062365b0a54364c7 + 6c160f11896c4794846ecfa14a71 + "" + 30 + c1 + 5890dc2ce6ae75f9c7072f3c06cc6aac; + c9f137120634c9519848a877ff + 77bf79192a5b50ade5d9cd + "" + 739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a + ba75fc237e106f6352333d944d8a6a0f8bfe641cf9242e343a63b4d591c2cdc18a6c50c88580b23e045876e62431d6d1 + e9af104923e66478d2bbac836c025af7; + 21635c6d62c9269029df3e6057 + acc87638f508046733d9ff61cd + bda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb6 + 21b7f65b000961040ef2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a480 + 856379775dd26a3b347f1e25434238aabccfbd70ecabff489dafd8d2d25fe86ae4cf09bd85f2c739f0365c4e7afb4bee + a43529bee26dd2393a369de5d2e23a55; + 30370c33d090c54215abd6b3ad + 54efc9a38378c5b93bf4f2aad260 + "" + 5faee2b03fb648e27fff63102758fe2b69ac26afa3349829b94586306fed54154f8f28523c03d4de1600157846b710ee72807a2219 + 60e28a1e146d789fa2b63320cfd0dbb8de71aad2d5f2df5200a8c179db39e2a64e8f7bc0926ac95fc11a65cbd36935bc03c8b13dca + 3666a5ec5c24466c0680e3d6062b30fd; + bfb474fd71d891f24bb65d1563 + 259f9eb53b571ea629c54d57dd2d + 42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f768281e040 + a9b9a222bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c + 513e8a344d74844ef67effb6805688174ea7685fd8ba3a2860cd98864c5bcc699b69fe97963dcfbcda987b28e4d649ca5d45378a13 + 6259e08c9387922cf33a2e5b86c23e38; + 037ba323fe1dc8151784873f + 0eb5b647da6794c18b5337685a96 + "" + "" + "" + cfafee3e2ee7315fefeac9f823d4ec1e; + ed65b9aca338527ef19b09c0 + 63c46f88de9fd41e72d7b97e23e6 + ea + "" + "" + 8fd186584d18210cb316f19fea0bd516; + bdff3bcd211499268878dbf3 + 0f1dad89d4b9b12012e4713df467 + "" + 95 + 33 + d846c750ec238730ef2611b41ef1d22f; + 630e7952d22bb02d7100b8b6 + 49377d20a8f083455b663e + "" + 4ee1315f3c8f2aebfa921451dcd1af5813b70d30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5e617669c0f + 66e0593cdc31156b9cca5bbce514957973bd0186966333560fbc521e413fb7b3ce7189751f51708bf4424cca548a00b0 + e4f02aebcee994443b0f438fd0d5e917; + 16e39815d4e9cfce3ed1ecdf + 3d264a7f16cb16c2e815f422cd + f0c8e30308be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed12ca986981a874498ad0abef8bc4f + cb70e27e98ef1f0446b42fb144d44b6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb + d182ac26587fc4ea051ef5e86830194d4f6afe030b7a72355dfc307eefffb85fc972a9e0ec73e25db66d4e98d8d7eb9d + 3905dfc881ebf47d63219f7a3824c03c; + 1c8dd0b00951f284649016ed + 00456331854bc78bf43966eb0cfa + "" + 9138ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c04226f + fac401c9710f7a1adf621eef0169fd85bb9efd3e5a2a59f2d985c72665c3fe1043563eee9bcfe24902ea2a20565ee073c556c0897d + ea51bd57dadb6f1b4aa5b85471a9b725; + 30cbb7f0e4a973a8cd190107 + 314717a77456f3ff669c732b58db + 8f48af65f7cc9e3fb90e1721b730374ffc9bc597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003cc0c + ae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f0911e32d65cc1770a18cbfe6effd1ff6778554acf1270485b203a3c1c4c967c0a4 + 7f34458b9f7bdb1075bd95a6577649bc50bbfedeedb3eaadad5610c87416621c2496fb61c94ad5ac6d1d157556260ed4ee9762c5df + 4e98bd96daadb7ba8885c55080fd944f; + 58cb948bdd409b68 + 7fa3a6827b480aa3a4c84cef64f6 + "" + "" + "" + 54a6dca9e4f6b456ca9a72d5430bf37f; + c9b53bf8f957f4b0 + 3cf43e89957f9a3e8128f8743d16 + 68 + "" + "" + 680d5049038160aeee6c7a4a3030990d; + 7b7bb8deb9bd205b + 70e04c091d205cdad9e9a79b1abf + "" + 91 + c0 + 3cf99a9f061f858ef7e0fb11d7f16467; + b0851e5ca605ac84 + 51399587011677508a15dd + "" + e524af3e2bee0646541a42c2ecccb44d65bad397abfaf529ee41cf9a05c7efedef3401539c51d2a90bbf7f1bfc338ab0 + f364b814e500ef9ab50b1f0c5cc2bddd2c00e7622f85716506453739fbb85ebd7c9c5d6bb06e1ac7974b640bab4fb2e2 + 538fef69d96b24725f40d036b7b6664e; + ef5746ea8fdcccd2 + 13e33f7e8a5718fd25014107c8 + e7d715a92add9589d1f5c054b2d983514605ec590294a319b9802068a9f891bc5ba5afabf8c3122d12d7ff3c41122d70 + d17d4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7abc8 + 4f968a35e00430a894fa0af39d8e46cbf5f6df56646d148532800533bc976923e4d9228a11def3ff976c6be7ccead573 + 9722d670c7a13c44d3fb8e0e97446166; + ad68daac90cfe22d + 2f1f2968cc42fa8b669ed3bb3542 + "" + a9cf44bbc8c6254d980398bd94e66eb4563d405e51881e99027b8ab9aea3ccf860b0009740763d96836c5f87b95460938de1288c69 + 237f19a52651cdcd603091b3ca1b5d7a3131761987c0f38664d0432917123bbee65ccaa962fdee1431aa26d2f247e05df2017a6f73 + 002e125c7224c549106c0c0f82d731ed; + d80ea12ff4bb5f06 + 9b8a2e86041c1b9fc214e9ca2186 + ddf1f6a7a3aa7e740da967828e3604b35b15ffaa6c36800d9645563a308ba60076817523bd2abf1261b089 + d8f23a9c2835076a23faac2cdd67771cc667a8331f0a170b66283e4f834a06148f302c3973accd56f6f24e33958b8c2e2352fd61e4 + 2094d61a83dedbd274dee89488d255879775fff59a5dcd4c270e2adab6e0d4ed7b48e867cd45400d77a667104d6a35a0056b5b9abe + dce0b2e1f5ba9e73aaff6246e384cbfe; + fa8fec816ac861a8b33779f09e7a10fc02 + a8f48afa3080ee119a52a9a817e4 + "" + "" + "" + 6dea6ebbce273e40bf6b5ba1481560d5; + f2b94b0820cab383a8cffeea7c48631579 + 9dc875fba578c8ec4837898a9214 + 2b + "" + "" + ef480ec30616d41fb86f4f79858304ca; + 5b0677da1ac273117b45bcfff5d5f8b6fd + e2893232a9f81d14517ffae475f6 + "" + b9 + 77 + 8af99e141e67210c5239e5d4f6016e59; + 4a43a67b3d380d2f9aaafe2dd721c0095c + 8808847689211450ba8095 + "" + ffab1eaadf66fd22ac1976063e113ab61f813e28a1397a7974a1d7f4220c785fe426a5a0e80f678d404147842941feef + b0315e2ce88fdc82212d14ff369becee4cc30d1e591bc73e9cb807b5014e50d2a03b416ccf7e403d0c788000d752c544 + 565bb827571e2d4746ea15001c3a511c; + fdc2eb44dc8c0d5e8f444f7f4e0c893959 + b74dc23a7bb40e7e0013e51506 + 86d2301b43a15a84e81d7f5cedaa49e2414ebf47970e560475cff206877de69146acc3ab6cf8556b7aa776945948d1b8 + 834df2196c92ec1718dcdeee0d52d9539726d2810391b3f9d10c39b07ae8f08ce7cee4758a386a9943e97dedfbe61e73 + 6882d9145b766d004aa23db26e6727b910a52b3524cf41e5b079063a5690876e00b8446bd49b8fe0f96c646a9de22fd0 + e1478799571f8ad2f2376901b4d0f0ba; + 7882cd09c2b9a80f34c0fde11c2481b11f + c76bfa4dbf710a9e544e0c536ca1 + "" + e040f9ad5b04140d98edabe08485290a4d87d13b07398a1458c2c6b61dbdbc1cccada8c1a0a9aabb6c4e3c3554f8fb1ef61614c270 + 9bfd938b0ddf7d005d20bab1060d8fae70cf3b084df0d31b76aeb0356f191bd9dd16f2a0ac6a6b4c910a7bb5982dc5ff5b7e99bf3a + 3fbd1c0a5b88616249b56c90758cdb29; + 295dfc0ca6551ca4bdb75359f91cb9d921 + 056b7de74fc9a9b37154ce6c0b39 + 6179d31f06a1dd5982cbc0d7cb23841da1ae8f4ae480cda98ad6cf2bacf6f9fd3f821330c43f3df6c2b3fa + c7cbcf96523d4723f91801325eb8553236651c96788d73d192ee53b3f3ebd66ddd98cedbe88e245de25b1593b70f8601562d90a9b5 + a58bb37e7d47cb624edd3d81393569f1b6dfe1cc7e50af93187a22abdef670f81e2ec2e0ddbc5a4fce6f61bfd15e642128305d6026 + 95512397bf2fdd2cb6111fd1763fe66b; +} + +cast256-ocb3-mct { + 32 620ecceaf099c7d1772580169dbe93a0; + 28 95fc3dcdf6e2582e821ad38cd6c26391; + 24 acef03ad345af5000cb5ef196bd366b7; + 20 0f1a6f49f6853abb75ce4e90c58599ea; + 16 4258d565f5ec42869802cd5cd5d21a96; + 12 f8fc10048890fb153d71d846be4ce8ed; + 10 aaab0bbcaa81d7b3b5b1269a3761335e; + 8 329c9f836301b423469a56ad770da468; + 4 68fc11ed2e38d35ba5bf89af2c9f856c; + 32 c0310249248a38ff9950a833; + 28 b97c775bf1d0c8ef8284fee6; + 24 67a579e69bf507321be80304; + 20 7077b0ec786e90698b31f028; + 16 f326d6be1d1c2758e6bc69b1; + 12 8f3110db5963f2e800f22f06; + 10 58a1c2500f16812836519b52; + 8 3d0e35b1e0cb21f08410d22f; + 4 6d9f16f675839f35d0a9bf7d; + 32 af8a0e5cd2075f9c; + 28 9610c921db423fd5; + 24 e228f80e94e1fe31; + 20 a7a0f74679eb7543; + 16 b64ea6aa7a4d2c86; + 12 695dda9261b41e4f; + 10 27064d4c545536b5; + 8 1868f259d6049ec2; + 4 fc3fd6f530c8c94e; +} diff --git a/symm/t/des b/symm/t/des index 6b2c1b02..8b3edb29 100644 --- a/symm/t/des +++ b/symm/t/des @@ -426,3 +426,99 @@ des-pmac1 { 36512061f7080cc07df0591d8fa21f2dd88374 0b547da65d93cc08; } + +des-ocb3 { + bef260d7bcda1635 + 47d348b75511 + "" + "" + "" + 4b59c22684f05b82; + 95e77022907dd1df + f7dac5c9941d + 26 + "" + "" + 4cd9eea7a5f450a6; + d0c6eb14ad568f86 + edd1dc9268ee + "" + ee + d2 + c2fd51cbecc7d7da; + 533285a6ed810c9b + 689daa + "" + a9060d2d4b6003062365b0a54364c76c160f11896c479484 + 5618b880cf7e0455afe09f1aa07e38de2eee04ffbba014a5 + a22ffdfcd123b06f; + 6ecfa14a7130c9f1 + 37120634c9 + 519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f29 + 549e6b0d27a4ba234085406a6136512061f7080cc07df059 + 7198f4d67f9d7ccae66e114745dd13b874d837fde0b5260a + e35c2d0fc8291130; + 1d8fa21f2dd88374 + d8cde8e160ad + "" + 10997a21635c6d62c9269029df3e6057acc87638f508046733d9ff61cd + a71a247ba8ca953a41dabaabf6c2c6a88f5e83c466a18fd8fd7b7595b8 + f00ab9e066d2b84b; + bda3b3e9878731eb + fedd4705e505 + da1435dceaa7b1cc49ae1d50c38201a894476b + 3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2fc5f + ac3adc8ac7c662d73901110404b26e56622c2b0208a34517256ca0876b + a5bd20d0748afcc7; + a450727a9b542c + de52ebfda19d + "" + "" + "" + 0fe8c6e02dfc921b; + 0ccc520f215eb5 + 7bb3a4f3ebbb + b1 + "" + "" + 70f6e10b0765c5e5; + 8ac6c95a97a480 + 30370c33d090 + "" + c5 + fc + e4a4438e74e98df5; + 4215abd6b3ad54 + efc9a3 + "" + 8378c5b93bf4f2aad2605faee2b03fb648e27fff63102758 + 659653c7ad91a79469d940fa2363013b939286f21cc49eee + f15e30c3bfe7697d; + fe2b69ac26afa3 + 349829b945 + 86306fed54154f8f28523c03d4de1600157846b710ee7280 + 7a2219bfb474fd71d891f24bb65d1563259f9eb53b571ea6 + ce4e983f478dbf2b09b3bad8af3dd6341645b8d4b492ff68 + d1179f9268c3b779; + 29c54d57dd2d42 + f70800df9fcb + "" + aca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cd + d337d3fd33b17c42b364dc862e8b85f506e4f444ed7f63ed4440b65bf8 + 898fa93ba1e83b92; + ec3f768281e040 + a9b9a222bd68 + 9aef66f5306ceb0c6b08ac8b0a22260c571b4a + 42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c03 + 139b42f78a74486d2488d4de046e14b0b8d9c49efc78718b87d5f72697 + 8e529f719d87d2ee; +} + +des-ocb3-mct { + 8 d3d27b14989225a9; + 7 eb3be38e3517c6d1; + 8 70d5d3c75417; + 7 93e83240fae6; + 8 bdc8b8e1; + 7 4407c007; +} diff --git a/symm/t/des3 b/symm/t/des3 index 868dfd05..afe7398a 100644 --- a/symm/t/des3 +++ b/symm/t/des3 @@ -782,3 +782,195 @@ des3-pmac1 { 8b77dba189196d1ebba10b0467cb9fc2712a19 129deaeec0e03d30; } + +des3-ocb3 { + 60d7bcda163547d348b7551195e7 + 7022907dd1df + "" + "" + "" + 9bd7647cc6fc5088; + f7dac5c9941d26d0c6eb14ad568f + 86edd1dc9268 + ee + "" + "" + 651a2beca10057bf; + ee533285a6ed810c9b689daaa906 + 0d2d4b600306 + "" + 23 + 61 + 55bdc89a749be10d; + 65b0a54364c76c160f11896c4794 + 846ecf + "" + a14a7130c9f137120634c9519848a877ff77bf79192a5b50 + 04994fd2405c66040b24f1e112d12a373a5ded3204e93dfc + 4d28060d06c1e6c9; + ade5d9cd739a3d1f337f29549e6b + 0d27a4ba23 + 4085406a6136512061f7080cc07df0591d8fa21f2dd88374 + d8cde8e160ad10997a21635c6d62c9269029df3e6057acc8 + bd32ead43e0c7e3cdf30ec74e82e9db51a480c4bce6dfdfe + 2440122fa77e088a; + 7638f508046733d9ff61cdbda3b3 + e9878731ebfe + "" + dd4705e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752e + e7086ac5c54bba010b3597e95d8035ba213d20c55f50558f13f3725cb8 + 5f2cd9483cb3a2ac; + b9529533966f27043eb621b7f65b + 000961040ef2 + f9b2fc5fa450727a9b542cde52ebfda19d0ccc + 520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215ab + 960f222b5a4b66a7a416bf51be1cbfbaffd7626fd3449cfac5ec66cd94 + 0cfa7a7a8b52f6d3; + d6b3ad54efc9a383 + 78c5b93bf4f2 + "" + "" + "" + f3be635a1f9bbcfa; + aad2605faee2b03f + b648e27fff63 + 10 + "" + "" + 27972bc75183a1f2; + 2758fe2b69ac26af + a3349829b945 + "" + 86 + 6d + 1449c4672751ce11; + 306fed54154f8f28 + 523c03 + "" + d4de1600157846b710ee72807a2219bfb474fd71d891f24b + 2f9edc04b832738964e4ef2c18a17b1eaf8ec0a325e08b9d + df25c2d0f9430d6f; + b65d1563259f9eb5 + 3b571ea629 + c54d57dd2d42f70800df9fcbaca48b77dba189196d1ebba1 + 0b0467cb9fc2712a199e533fa9156308cdec3f768281e040 + c6b34746675339e4f07cc680e5b8e3e5da5541a92c659459 + a6d7adc34d54cb89; + a9b9a222bd689aef + 66f5306ceb0c + "" + 6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49 + 79c706a66a8ebc8376e149588ab5584dcc7d59a37782abce2725bf2831 + 9d6ffb6e4cb098a5; + cb3b6f5fe8368131 + 115c037ba323 + fe1dc8151784873f0eb5b647da6794c18b5337 + 685a96ed65b9aca338527ef19b09c063c46f88de9fd41e72d7b97e23e6 + da06bb4d2dc9612e2b9e1f38b4a9cf88c5f93c0ebbc12dc6894c42fb73 + 86be658d949b0120; + eabdff3bcd211499268878dbf30f1dad + 89d4b9b12012 + "" + "" + "" + a2599ce8b6a5832e; + e4713df46795630e7952d22bb02d7100 + b8b649377d20 + a8 + "" + "" + 1b9d7c64f893467a; + f083455b663e4ee1315f3c8f2aebfa92 + 1451dcd1af58 + "" + 13 + d4 + 7702114c8465f527; + b70d30ce2f1fef6ef315d0798391805d + a08da3 + "" + aefc5f8584b7c5e617669c0f16e39815d4e9cfce3ed1ecdf + 23275152a0a4c447adf86084cad8e537778f46150a4430aa + a44aba0c5685823a; + 3d264a7f16cb16c2e815f422cdf0c8e3 + 0308be3c31 + e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd5214 + 7ed12ca986981a874498ad0abef8bc4fcb70e27e98ef1f04 + 55917e61b80378e828b2cb53911b751df969fb0aaf39a0a1 + cc006e8fa8f47da1; + 46b42fb144d44b6d00f06dc188d472a7 + 84e0c6f21195 + "" + a3b9f4ae985511265febd11c164720eef9eb1c8dd0b00951f284649016 + 67426920d7bb581d90c8c9b561d504d9729a024b2d26a34233f624bf35 + 3e0e6eaf9b8d41c2; + ed00456331854bc78bf43966eb0cfa91 + 38ddc3990844 + 5608fe95e81c2533e31c9c1a9851bc2810d858 + cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c04226f30cb + 42eff82d31f0ca1cb79604219601c56c9d4e60ea08ab0e2be33b87fd70 + 70e2f64112ef6d62; + b7f0e4a973a8cd190107314717a77456f3ff669c73 + 2b58db8f48af + "" + "" + "" + f8608b8da49f9700; + 65f7cc9e3fb90e1721b730374ffc9bc597f56ccbb2 + f294b38766fc + 69 + "" + "" + df345d63832f4e3d; + f6a9f2c0945ffd505003cc0cae9ce021a5f1fa4ffa + 91544485f1a1 + "" + 25 + eb + 17c6a45486274633; + 8b2b9b8f0911e32d65cc1770a18cbfe6effd1ff677 + 8554ac + "" + f1270485b203a3c1c4c967c0a458cb948bdd409b687fa3a6 + 359c9f7d642db7d7d35ed57a183a25212c054d25a4de09e3 + 065d208592dbdc5c; + 827b480aa3a4c84cef64f6c9b53bf8f957f4b03cf4 + 3e89957f9a + 3e8128f8743d16687b7bb8deb9bd205b70e04c091d205cda + d9e9a79b1abf91b0851e5ca605ac8451399587011677508a + 271c63ace6900ca3d2ea38737ff73f9298b4f6484ff4c916 + 32315b959ad39d8f; + 15dde524af3e2bee0646541a42c2ecccb44d65bad3 + 97abfaf529ee + "" + 41cf9a05c7efedef3401539c51d2a90bbf7f1bfc338ab0ef5746ea8fdc + 0a1bc356fb7cbe2959c09e1c504326d0544a16fa91596ca1bfbf69cd9f + 0c1a33dffaebcbb8; + ccd213e33f7e8a5718fd25014107c8e7d715a92add + 9589d1f5c054 + b2d983514605ec590294a319b9802068a9f891 + bc5ba5afabf8c3122d12d7ff3c41122d70d17d4569eaff59a332ba58d5 + 0e2f842eda3840dd0b22d2e5ec4e7280d96916ca08fa43b74ce34d1be9 + 32dc28ff4706c6fb; +} + +des3-ocb3-mct { + 24 d3d27b14989225a9; + 21 eb3be38e3517c6d1; + 16 07135a64481e5862; + 14 812edbcd44bd9e1a; + 8 d3d27b14989225a9; + 7 eb3be38e3517c6d1; + 24 70d5d3c75417; + 21 93e83240fae6; + 16 58382ba741ab; + 14 6c492c0d482a; + 8 70d5d3c75417; + 7 93e83240fae6; + 24 bdc8b8e1; + 21 4407c007; + 16 0654310f; + 14 e2591768; + 8 bdc8b8e1; + 7 4407c007; +} diff --git a/symm/t/desx b/symm/t/desx index bbc1f67b..70bb2227 100644 --- a/symm/t/desx +++ b/symm/t/desx @@ -734,3 +734,195 @@ desx-pmac1 { 67cb9fc2712a199e533fa9156308cdec3f7682 462473f2102f3c1d; } + +desx-ocb3 { + 60d7bcda163547d348b7551195e770 + 22907dd1dff7 + "" + "" + "" + 421aa0e31e3c1a41; + dac5c9941d26d0c6eb14ad568f86ed + d1dc9268eeee + 53 + "" + "" + 7bb6a8ce983ccb5e; + 3285a6ed810c9b689daaa9060d2d4b + 6003062365b0 + "" + a5 + 0d + ca4e70eaefa59040; + 4364c76c160f11896c4794846ecfa1 + 4a7130 + "" + c9f137120634c9519848a877ff77bf79192a5b50ade5d9cd + d0075d682bb032d318f435f35ed9e7e0dd2e759b18346051 + 3c5c9c5dab448848; + 739a3d1f337f29549e6b0d27a4ba23 + 4085406a61 + 36512061f7080cc07df0591d8fa21f2dd88374d8cde8e160 + ad10997a21635c6d62c9269029df3e6057acc87638f50804 + 2b0daddf1c1562ed4ec92feba5fc19abb1a7d7fe85035cc3 + b574000108612b30; + 6733d9ff61cdbda3b3e9878731ebfe + dd4705e505da + "" + 1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f + f9d6ea23faa8a36974e06d38d9061790875f1e4523e9f8eccb89dd8c13 + 73bdbd55cfa011e8; + 27043eb621b7f65b000961040ef2f9 + b2fc5fa45072 + 7a9b542cde52ebfda19d0ccc520f215eb57bb3 + a4f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a3 + 21b80b17c3caf1e5b5fdabe9f9ce4fec36e20cae0a9c9b1e85167041be + 68f794a0eb64f247; + 8378c5b93bf4f2aa + d2605faee2b0 + "" + "" + "" + fd8891d8d9802520; + 3fb648e27fff6310 + 2758fe2b69ac + 26 + "" + "" + ce479a676926cc17; + afa3349829b94586 + 306fed54154f + "" + 8f + d7 + d92beba1b5d650db; + 28523c03d4de1600 + 157846 + "" + b710ee72807a2219bfb474fd71d891f24bb65d1563259f9e + 6818636db15d3a46dc05078583752a6a774b1b514bdea903 + c5958bbdef31bba2; + b53b571ea629c54d + 57dd2d42f7 + 0800df9fcbaca48b77dba189196d1ebba10b0467cb9fc271 + 2a199e533fa9156308cdec3f768281e040a9b9a222bd689a + 22dfcb714017ac0ad765d20593b65444a234a59dd3fc1abb + aa605331fbc55268; + ef66f5306ceb0c6b + 08ac8b0a2226 + "" + 0c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe83681 + 40a58a44dd58cd9e44d06391edc4ec2916d3b29628c61ad9084f56cc29 + 436c5a2b1728295f; + 31115c037ba323fe + 1dc815178487 + 3f0eb5b647da6794c18b5337685a96ed65b9ac + a338527ef19b09c063c46f88de9fd41e72d7b97e23e6eabdff3bcd2114 + 2b6d4c2462ad510a000d9df521066c02a81e31d5873c66343deb78fce2 + 77a855f0a7d42e18; + 99268878dbf30f1dad89d4b9b12012e4 + 713df4679563 + "" + "" + "" + 2685c7810bf996c5; + 0e7952d22bb02d7100b8b649377d20a8 + f083455b663e + 4e + "" + "" + a25ea075d7bc735a; + e1315f3c8f2aebfa921451dcd1af5813 + b70d30ce2f1f + "" + ef + ef + e4ea88484e9e6b1e; + 6ef315d0798391805da08da3aefc5f85 + 84b7c5 + "" + e617669c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb16 + fd6a65b03ae4567f3c6a94e573da790cb684b8d5bd32e3fd + 754c91fb0050e81e; + c2e815f422cdf0c8e30308be3c31e6bc + 58c0b7cadc + b658b970e47479a684b5aefa69a4cd52147ed12ca986981a + 874498ad0abef8bc4fcb70e27e98ef1f0446b42fb144d44b + 5c9347f1dc4853413edfe418d369932c21212122dac2955d + 92362b5fed50868c; + 6d00f06dc188d472a784e0c6f21195a3 + b9f4ae985511 + "" + 265febd11c164720eef9eb1c8dd0b00951f284649016ed00456331854b + 6f62164db8d9a857e36ca6eef9bbdcba9d01743165ee7acd87fe754d0d + a55e71bcc128168d; + c78bf43966eb0cfa9138ddc399084456 + 08fe95e81c25 + 33e31c9c1a9851bc2810d858cbbc8424d126b8 + 07e6daa089c3f9099c5ffb824173d7634c04226f30cbb7f0e4a973a8cd + 1c394e0b510d366554dd0afcb0c6b0b4e9437fb1c83355753863e2eec9 + 86560f52894b7d41; + 190107314717a77456f3ff669c732b58db8f48af65f7cc + 9e3fb90e1721 + "" + "" + "" + a4205f9ab2399111; + b730374ffc9bc597f56ccbb2f294b38766fc69f6a9f2c0 + 945ffd505003 + cc + "" + "" + 5078f8d6fa0e866a; + 0cae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f0911 + e32d65cc1770 + "" + a1 + 32 + 87fddf9b28a92f55; + 8cbfe6effd1ff6778554acf1270485b203a3c1c4c967c0 + a458cb + "" + 948bdd409b687fa3a6827b480aa3a4c84cef64f6c9b53bf8 + b1af8fefb936518c083e54b9c67363455a1f642e253c0918 + 159d0ce2b235b273; + f957f4b03cf43e89957f9a3e8128f8743d16687b7bb8de + b9bd205b70 + e04c091d205cdad9e9a79b1abf91b0851e5ca605ac845139 + 9587011677508a15dde524af3e2bee0646541a42c2ecccb4 + ef425d80e98f3681592695628ed0a816418fa5899b1d1d42 + f29bb2c9e21839c7; + 4d65bad397abfaf529ee41cf9a05c7efedef3401539c51 + d2a90bbf7f1b + "" + fc338ab0ef5746ea8fdcccd213e33f7e8a5718fd25014107c8e7d715a9 + 2c4a2be80fd7d3f7b3b5a4ef05a6540fb6798601ad3623aaab10d0ac60 + a1ed9a02743fa18a; + 2add9589d1f5c054b2d983514605ec590294a319b98020 + 68a9f891bc5b + a5afabf8c3122d12d7ff3c41122d70d17d4569 + eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2 + 81c230d8f7e0294cbbb8fe659f94a74332801000f5b5f49b74ce635cc0 + 9d5ceb6d322cfa12; +} + +desx-ocb3-mct { + 24 b8a0fa1c0e3e1201; + 23 b8a0fa1c0e3e1201; + 16 08afcdeda8acc974; + 15 0c967b6cca833a3c; + 8 d3d27b14989225a9; + 7 eb3be38e3517c6d1; + 24 0418ab9332b6; + 23 0418ab9332b6; + 16 aff581b9de59; + 15 2b546df8e00c; + 8 70d5d3c75417; + 7 93e83240fae6; + 24 802690b2; + 23 802690b2; + 16 cf467380; + 15 c874e69c; + 8 bdc8b8e1; + 7 4407c007; +} diff --git a/symm/t/idea b/symm/t/idea index 0ab91400..c51e842a 100644 --- a/symm/t/idea +++ b/symm/t/idea @@ -216,3 +216,53 @@ idea-pmac1 { 120634c9519848a877ff77bf79192a5b50ade5 64b5b29952d302fd; } + +idea-ocb3 { + e4bef260d7bcda163547d348b7551195 + e77022907dd1 + "" + "" + "" + d4146d9749c5b4cc; + dff7dac5c9941d26d0c6eb14ad568f86 + edd1dc9268ee + ee + "" + "" + 91344823fdca261a; + 533285a6ed810c9b689daaa9060d2d4b + 6003062365b0 + "" + a5 + 32 + bd1e855f2cfab6a4; + 4364c76c160f11896c4794846ecfa14a + 7130c9 + "" + f137120634c9519848a877ff77bf79192a5b50ade5d9cd73 + 9de3e559bcf16005a54f07a11b791f0c87486d260cd04d40 + 0f6c004bce2fdfa4; + 9a3d1f337f29549e6b0d27a4ba234085 + 406a613651 + 2061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10 + 997a21635c6d62c9269029df3e6057acc87638f508046733 + 07d9e965ec0f32d6ba5393c0504a9e274d18fbb31e705f7e + d1f5621c6fa3f2c9; + d9ff61cdbda3b3e9878731ebfedd4705 + e505da1435dc + "" + eaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043e + a51612481f15245dfec7f8e1ffa9bc47788140faac776d8fce971d2d96 + 2030845d5729cf4f; + b621b7f65b000961040ef2f9b2fc5fa4 + 50727a9b542c + de52ebfda19d0ccc520f215eb57bb3a4f3ebbb + b18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b9 + cb28e83ecdf27012219f655bf27bb37de417f09f4337a92bfe5feb3da2 + cc56a222f733795e; +} +idea-ocb3-mct { + 16 81bc29159fbaf9aa; + 16 fb5ea26d7558; + 16 1749134c; +} diff --git a/symm/t/mars.local b/symm/t/mars.local index a5977585..126fddf9 100644 --- a/symm/t/mars.local +++ b/symm/t/mars.local @@ -713,3 +713,210 @@ mars-pmac1 { 9c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0b7cadcb6 b4e1b487ca7856e1a27ae343a761962f; } + +mars-ocb3 { + 60d7bcda163547d348b75511 + 95e77022907dd1dff7dac5c9941d + "" + "" + "" + 7c296d4449e64315d2b9f9ba0c3ff7d1; + 26d0c6eb14ad568f86edd1dc + 9268eeee533285a6ed810c9b689d + aa + "" + "" + b430fac783a66cc2daed259760916412; + a9060d2d4b6003062365b0a5 + 4364c76c160f11896c4794846ecf + "" + a1 + 67 + 06f7540f39167c5adfddad27cf702a2c; + 4a7130c9f137120634c95198 + 48a877ff77bf79192a5b50 + "" + ade5d9cd739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160 + 871488d35db8121121e6c850c22cf29166fe1e351ce6f6027053f625dae6bded20dff82b546f8ba0806af4a9df2e3cd3 + 1cd5f303f4b515ea7c331533b41f4ac7; + ad10997a21635c6d62c92690 + 29df3e6057acc87638f5080467 + 33d9ff61cdbda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb952953396 + 6f27043eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6 + 04aecdbb5ea1f384759cb21f922d4a5e5f41759933e7e12a46761a0bb58e8b13100338f8ac4f5d71a564d51d2e7ecefc + 0fdac739fa9705100fb282f9c9c99668; + c95a97a48030370c33d090c5 + 4215abd6b3ad54efc9a38378c5b9 + "" + 3bf4f2aad2605faee2b03fb648e27fff63102758fe2b69ac26afa3349829b94586306fed54154f8f28523c03d4de1600157846b710 + ecec35b67e05827d1c60b59197ddec40a4afc502e7b22194c710f2d5bb806fca221d81abdce4c507e02f65b5cca4e43f86f5f76f5f + 4eba3f34ab847bcb7fc65d5b06406cec; + ee72807a2219bfb474fd71d8 + 91f24bb65d1563259f9eb53b571e + a629c54d57dd2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cd + ec3f768281e040a9b9a222bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f + ff28ac43e2c855d679ee89f7f8d4107c8a1c7c20a4f03b59544adaedd185a4e3a5a37ca45dc55e11df1cdaa7a374850225bffc3c26 + 2da2a1575b5dc344c32a8b2a0b4c3dd8; + 5fe8368131115c037ba323fe1dc8151784873f0e + b5b647da6794c18b5337685a96ed + "" + "" + "" + f940a9debe160996da1f147aafcc566a; + 65b9aca338527ef19b09c063c46f88de9fd41e72 + d7b97e23e6eabdff3bcd21149926 + 88 + "" + "" + 92001d0836b97d87051c1f7d9d09f202; + 78dbf30f1dad89d4b9b12012e4713df46795630e + 7952d22bb02d7100b8b649377d20 + "" + a8 + 74 + 67e9a575f013c2692d295c6103d0d0cf; + f083455b663e4ee1315f3c8f2aebfa921451dcd1 + af5813b70d30ce2f1fef6e + "" + f315d0798391805da08da3aefc5f8584b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cd + 0a797f00e405100dadb704f4ff09a0a4a8cbe6cd46a0b27529f64b9c56f9d70e688fbe551fa24eb5d3609185b4bdceed + b672df8063219f6c88308bdd3a3ad799; + f0c8e30308be3c31e6bc58c0b7cadcb658b970e4 + 7479a684b5aefa69a4cd52147e + d12ca986981a874498ad0abef8bc4fcb70e27e98ef1f0446b42fb144d44b6d00f06dc188d472a784e0c6f21195a3b9f4 + ae985511265febd11c164720eef9eb1c8dd0b00951f284649016ed00456331854bc78bf43966eb0cfa9138ddc3990844 + badad19dc5594c261a3c5f532b3dcfadfbb81fc53ed47dc2ed8327af497dd998714d1a882310f27ff3cb2c59c024d6e6 + e4b3b99d7d2e296fb0c0de581f1b5fe9; + 5608fe95e81c2533e31c9c1a9851bc2810d858cb + bc8424d126b807e6daa089c3f909 + "" + 9c5ffb824173d7634c04226f30cbb7f0e4a973a8cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e3fb90e1721b73037 + 21a942eb29d65d2fbf4807ccbb084336916f1003941785547a5346c7eab40931819df2d8caa2549e942e1d09b84b260c7a0dfc0a10 + 672ef4305dcce1cfe09539670b14a261; + 4ffc9bc597f56ccbb2f294b38766fc69f6a9f2c0 + 945ffd505003cc0cae9ce021a5f1 + fa4ffa91544485f1a1258b2b9b8f0911e32d65cc1770a18cbfe6effd1ff6778554acf1270485b203a3c1c4 + c967c0a458cb948bdd409b687fa3a6827b480aa3a4c84cef64f6c9b53bf8f957f4b03cf43e89957f9a3e8128f8743d16687b7bb8de + 2d0975faff0cd18b98e72bd93765dd3abd35cc4e3cfeb0b6cac1e15e9ed12b4aa038f51cc89b3576ff38a268be71215c4b01dcd552 + b5237448fba31d61ebda5eeac052d5d6; + b9bd205b70e04c09 + 1d205cdad9e9a79b1abf91b0851e + "" + "" + "" + 20c493b7bdf626905c987fb7bf10d8f7; + 5ca605ac84513995 + 87011677508a15dde524af3e2bee + 06 + "" + "" + fa2df8b2eaad48b6bdf3c9bad2938049; + 46541a42c2ecccb4 + 4d65bad397abfaf529ee41cf9a05 + "" + c7 + 75 + 435dd63a2ce8c8458535cd09b20f8d3a; + efedef3401539c51 + d2a90bbf7f1bfc338ab0ef + "" + 5746ea8fdcccd213e33f7e8a5718fd25014107c8e7d715a92add9589d1f5c054b2d983514605ec590294a319b9802068 + 64e098d90cbf96bc76262ab532cc962b17fa5c87938daba74d1af81bac2132abb0ff7c47ce79b02b4d6c863ef802d79b + f9732cb1c9f81e4e2a18bc027bb54a19; + a9f891bc5ba5afab + f8c3122d12d7ff3c41122d70d1 + 7d4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7abc8ad + 68daac90cfe22d2f1f2968cc42fa8b669ed3bb3542a9cf44bbc8c6254d980398bd94e66eb4563d405e51881e99027b8a + bd7f51b29f6c6f31d1be0eb43533bf93f1b32117242de5011d5e8b25fbb5692531fd3a6c9b48fad09bc80a142ff50ee1 + 86ebc023b905ca6caa36f50a8e18843d; + b9aea3ccf860b000 + 9740763d96836c5f87b95460938d + "" + e1288c69d80ea12ff4bb5f069b8a2e86041c1b9fc214e9ca2186ddf1f6a7a3aa7e740da967828e3604b35b15ffaa6c36800d964556 + fe4fa4d02555e61c0bd04dff129a4d6936fb1f73d65dd7cd97bb33cb2367ad3cd6e837306ce8bb8f7ae139034d288069d9b25e8c60 + ca2f4b45a793978f9bf62457f035ac75; + 3a308ba600768175 + 23bd2abf1261b089d8f23a9c2835 + 076a23faac2cdd67771cc667a8331f0a170b66283e4f834a06148f302c3973accd56f6f24e33958b8c2e23 + 52fd61e4fa8fec816ac861a8b33779f09e7a10fc02a8f48afa3080ee119a52a9a817e4f2b94b0820cab383a8cffeea7c486315799d + b15d10be578b00205857262c9108b92645914a0824925535feb7486fb53037fb93d5ff7d77acede5ddf9ece2422636baa4817f4ebb + adff289af064bd7145e742df30acc5fd; + c875fba578c8ec4837898a92142b5b0677da1ac273117b45bcfff5d5f8b6fde2893232a9 + f81d14517ffae475f6b94a43a67b + "" + "" + "" + 0742d3aab5b5f4338953a42eff9de1e4; + 3d380d2f9aaafe2dd721c0095c8808847689211450ba8095ffab1eaadf66fd22ac197606 + 3e113ab61f813e28a1397a7974a1 + d7 + "" + "" + 9960763f7362f798c6ca3adf09317bd1; + f4220c785fe426a5a0e80f678d404147842941feeffdc2eb44dc8c0d5e8f444f7f4e0c89 + 3959b74dc23a7bb40e7e0013e515 + "" + 06 + 2d + 1896462db7d41cf1dfc0e73f56e35e49; + 86d2301b43a15a84e81d7f5cedaa49e2414ebf47970e560475cff206877de69146acc3ab + 6cf8556b7aa776945948d1 + "" + b8834df2196c92ec1718dcdeee0d52d9539726d2810391b3f9d10c39b07ae8f08ce7cee4758a386a9943e97dedfbe61e + 6a517fb1eddc5a9ffcf4b4dcae0c9d2e2f8f70b843e480d9b86d71fdbeebacd5a135f08de14ed70906ccbc4f6107b425 + e699532063bc347b5273ab6c9aa5f8a7; + 737882cd09c2b9a80f34c0fde11c2481b11fc76bfa4dbf710a9e544e0c536ca1e040f9ad + 5b04140d98edabe08485290a4d + 87d13b07398a1458c2c6b61dbdbc1cccada8c1a0a9aabb6c4e3c3554f8fb1ef61614c270295dfc0ca6551ca4bdb75359 + f91cb9d921056b7de74fc9a9b37154ce6c0b396179d31f06a1dd5982cbc0d7cb23841da1ae8f4ae480cda98ad6cf2bac + 8908a7b2b68ebc9659feb4a31163481275f0db4182b7051a9a50e9697f8115ff79368964e9661b2e2db5d2a4c86b5a23 + 33756a80721be9f1105c7afd703e21a0; + f6f9fd3f821330c43f3df6c2b3fac7cbcf96523d4723f91801325eb8553236651c96788d + 73d192ee53b3f3ebd66ddd98cedb + "" + e88e245de25b1593b70f8601562d90a9b59ed034a867642d25d54756fa5c47f16f64b837bb4926214211a1c696ba172010abb43392 + cdcec7225d6eb19a12720cc24c2a672559618debfdf0ee0d0b350e2701a69124f28d1b76b322cecdadbc67e99342c59dabd11fbf23 + fb30f854d45a706e84616a756a52e711; + 2a22d9fd881519165eb9d85197a21cc34ac0d5ae7be8dbf98e4ffed2cf6b1372a5aa47b5 + 4fd9d70c70e117bf1cae71b3a56f + 0e7d839ea59cc783443d64f2ed6a29b96856beca34fd6544bcf86b799e2a1681160ccf055f0fd3001da597 + a1406d465b7b1419ea51cf858f938f6daafbd656445a09898eaa96ffc3d1d2e31e4e34c94b8bfae64825ecd75a66d88eedb969ffe0 + 98463b6aa0363435ef5f9a71e67406202f51153781195a36bf467b301bf4a676c5af0b7011e15f1ecff79112847529137666ffe910 + 684543c8dbf9b01aee18f5eba0153a24; +} + +mars-ocb3-mct { + 56 3ba8a3d94c3f67e9cef8cf2142b367f7; + 52 f743099826d0e38c48faf27d3edd5b22; + 48 4345a17ed61d2a7b9289f0e12e4350f5; + 44 ef3ad940f5e754a02317f3f1c489028c; + 40 c618d5f97d8913f90a91caed561346c7; + 36 96249ddf7bd91b1df2e2aed3c09bd194; + 32 1f789304aff2376bf2feba8aa9191a05; + 28 7a339727e025fcf65c08152217b95583; + 24 d4d38f1f399005a03a185887fbcc6737; + 20 45e7020dbfdd5f6d31cb441096faf69c; + 16 6b5c2f90abb45cda3622baa74d486f02; + 56 15a0597529ff0ec495e2abc1; + 52 fbd7bfc60b66a65582e96109; + 48 ae651ff80d12c1940539ae3e; + 44 35db8939f38ed596f9940968; + 40 fc4127740b0b0b7c07d2cf62; + 36 282eec1a27cf55e9cda791b1; + 32 95f745dd397a29d2dbcca030; + 28 6935deaa6bc7da04dc7ab3e9; + 24 f46ff7af02ea94fa45404e09; + 20 2f41619c9f36bc9ed459d3b9; + 16 c02f5b63d1ccbe71e928b16f; + 56 05f4e466ef576d08; + 52 b260ce024131b9ba; + 48 ad7f2b73670c5238; + 44 00a12cf14f6300bb; + 40 f0bfc04f2ea1275a; + 36 48585bf1735225ea; + 32 838abfef38920bee; + 28 fe4f81e7b258e614; + 24 b1791137318f5946; + 20 d67d45622c856251; + 16 f34b97c87f3e6823; +} diff --git a/symm/t/noekeon b/symm/t/noekeon index 0ab37b9a..02382288 100644 --- a/symm/t/noekeon +++ b/symm/t/noekeon @@ -200,3 +200,54 @@ noekeon-pmac1 { 1f337f29549e6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10 35b9675a79680b83422e4282cc260583; } + +noekeon-ocb3 { + e4bef260d7bcda163547d348b7551195 + e77022907dd1dff7dac5c9941d26 + "" + "" + "" + 064d07192f9b79d8bc4611a94783465b; + d0c6eb14ad568f86edd1dc9268eeee53 + 3285a6ed810c9b689daaa9060d2d + 4b + "" + "" + 37ad7dbe61111839a2bbead7eec6358a; + 6003062365b0a54364c76c160f11896c + 4794846ecfa14a7130c9f1371206 + "" + 34 + 76 + 73f39959389362724e3785d929b00e8c; + c9519848a877ff77bf79192a5b50ade5 + d9cd739a3d1f337f29549e + "" + 6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029 + 820db0cbad206848e689523feda637ed12f58eaa9f133457937c505778b55369994f1c339ca3d2c044578450d5905c22 + a0205c94e65a8712262a1d127f9d22da; + df3e6057acc87638f508046733d9ff61 + cdbda3b3e9878731ebfedd4705 + e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2 + fc5fa450727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3 + d79866f055cda0abb2ad06098f8c651ed32d5550d021bfd59fffd34433b04483d0d402fce3309a760720fadd094c8ee1 + 14c60ff87068d3d52be11c8472174f77; + ad54efc9a38378c5b93bf4f2aad2605f + aee2b03fb648e27fff63102758fe + "" + 2b69ac26afa3349829b94586306fed54154f8f28523c03d4de1600157846b710ee72807a2219bfb474fd71d891f24bb65d1563259f + dcda3a90b5db824f1d54c569db8d543bb323ff0aa596a8779b7b94c3f397b193e3762cea731fe84ed5e7bd517641466550043faad9 + b92101660872e1e7a951e8d8bab834c9; + 9eb53b571ea629c54d57dd2d42f70800 + df9fcbaca48b77dba189196d1ebb + a10b0467cb9fc2712a199e533fa9156308cdec3f768281e040a9b9a222bd689aef66f5306ceb0c6b08ac8b + 0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c037ba323fe1dc8151784873f0eb5b647da67 + 42b20072cef90e896f11993737b645f8e42c172527cd4ddaa5ec2e54d4bb7f234062d707b63c87624b8e16273bce20e835f3374199 + 915583e7c80edec73b6d59c12a2a196f; +} + +noekeon-ocb3-mct { + 16 4d9b245d6fab392f1c5364a2ef5b96fb; + 16 3b08aa07a8a40dc29e87a831; + 16 9e400fc6449969f2; +} diff --git a/symm/t/rc2 b/symm/t/rc2 index 46200b29..78c134a6 100644 --- a/symm/t/rc2 +++ b/symm/t/rc2 @@ -725,3 +725,198 @@ rc2-pmac1 { f4b03cf43e89957f9a3e8128f8743d16687b7b 2eb16505976b0bf1; } + +rc2-ocb3 { + 60d7bcda163547d348b7551195e77022907dd1dff7dac5c9941d26d0c6eb14ad568f86edd1dc9268ee + ee533285a6ed + "" + "" + "" + 581f918026a62a86; + 810c9b689daaa9060d2d4b6003062365b0a54364c76c160f11896c4794846ecfa14a7130c9f1371206 + 34c9519848a8 + 77 + "" + "" + 0f2f73159c7260d2; + ff77bf79192a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7080cc07d + f0591d8fa21f + "" + 2d + af + f64c74ec46bb90b1; + d88374d8cde8e160ad10997a21635c6d62c9269029df3e6057acc87638f508046733d9ff61cdbda3b3 + e98787 + "" + 31ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a8 + 055814531dcb494c81bdd40c6b320ac9cdf3f6b48b3e62ca + 9624c68017513bf7; + 94476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde52 + ebfda19d0c + cc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33 + d090c54215abd6b3ad54efc9a38378c5b93bf4f2aad2605f + 7dbbed27e29a669ee60e79d868848e797cf8d585fa877eef + b181420c050f46bb; + aee2b03fb648e27fff63102758fe2b69ac26afa3349829b94586306fed54154f8f28523c03d4de1600 + 157846b710ee + "" + 72807a2219bfb474fd71d891f24bb65d1563259f9eb53b571ea629c54d + d2edbee66b1039b346ad18f087e5712227159fa306a398b03c5805ebaa + 7f3a208c993f1401; + 57dd2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f + 768281e040a9 + b9a222bd689aef66f5306ceb0c6b08ac8b0a22 + 260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe836 + a7d224261bc9eed46f062bad5ce6acf20db49e5efa965da235a6cbfcf2 + 800f8ff9dbcbfcfb; + 8131115c037ba323fe1dc8151784873f0eb5b647da6794c18b5337685a96ed65b9aca338527ef19b09c063c46f88de9fd41e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89d4b9b12012e4713df46795630e7952d22bb02d7100b8b649377d20a8f083455b663e4ee1315f3c8f2aebfa921451 + dcd1af5813b7 + "" + "" + "" + abdbde1d369f81cf; + 0d30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed12ca986981a874498ad0abef8bc4fcb70e27e98ef1f0446b42fb144d44b6d + 00f06dc188d4 + 72 + "" + "" + 8a82cb9899ea8c5e; + a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb1c8dd0b00951f284649016ed00456331854bc78bf43966eb0cfa9138ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c04226f30cbb7f0e4a973a8cd190107314717 + a77456f3ff66 + "" + 9c + e6 + 0d8c6497b6eae6d2; + 732b58db8f48af65f7cc9e3fb90e1721b730374ffc9bc597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003cc0cae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f0911e32d65cc1770a18cbfe6effd1ff6778554acf1270485b203a3c1c4c967c0a458cb948bdd409b687fa3a6827b480aa3a4c84c + ef64f6 + "" + c9b53bf8f957f4b03cf43e89957f9a3e8128f8743d16687b + 49ef16eee0810eecd3e8dab4f26ab52a367325b186d5829e + 1703b30f19f8fd57; + 7bb8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605ac8451399587011677508a15dde524af3e2bee0646541a42c2ecccb44d65bad397abfaf529ee41cf9a05c7efedef3401539c51d2a90bbf7f1bfc338ab0ef5746ea8fdcccd213e33f7e8a5718fd25014107c8e7d715a92add9589d1 + f5c054b2d9 + 83514605ec590294a319b9802068a9f891bc5ba5afabf8c3 + 122d12d7ff3c41122d70d17d4569eaff59a332ba58d5d558 + 6d390ba093cfe6c87e7d319eb6aa78bad09fc27ef0901b6e + 44577228a64debfa; + 9bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7abc8ad68daac90cfe22d2f1f2968cc42fa8b669ed3bb3542a9cf44bbc8c6254d980398bd94e66eb4563d405e51881e99027b8ab9aea3ccf860b0009740763d96836c5f87b95460938de1288c69d80ea12ff4bb5f069b8a + 2e86041c1b9f + "" + c214e9ca2186ddf1f6a7a3aa7e740da967828e3604b35b15ffaa6c3680 + 7c69cf94aeefeb59424b9cea58a906052733cd4218668705ab2853691c + e4f0891347b99255; + 0d9645563a308ba60076817523bd2abf1261b089d8f23a9c2835076a23faac2cdd67771cc667a8331f0a170b66283e4f834a06148f302c3973accd56f6f24e33958b8c2e2352fd61e4fa8fec816ac861a8b33779f09e7a10fc02a8f48afa3080ee119a52a9a817e4f2b94b0820cab383a8cffeea7c4863 + 15799dc875fb + a578c8ec4837898a92142b5b0677da1ac27311 + 7b45bcfff5d5f8b6fde2893232a9f81d14517ffae475f6b94a43a67b3d + 625cdc216187b9b9c5fa391d280bfa6b305ba1cb1fdd3724d8a72e1ac7 + 519207d1413a1b4d; + 380d2f9aaafe2dd721c0095c88088476892114 + 50ba8095ffab + "" + "" + "" + 06cfa98d411047e9; + 1eaadf66fd22ac1976063e113ab61f813e28a1 + 397a7974a1d7 + f4 + "" + "" + 175d23bbcafb83d7; + 220c785fe426a5a0e80f678d404147842941fe + effdc2eb44dc + "" + 8c + 58 + 5468b08a313669e1; + 0d5e8f444f7f4e0c893959b74dc23a7bb40e7e + 0013e5 + "" + 150686d2301b43a15a84e81d7f5cedaa49e2414ebf47970e + ad2f294aef829753411546662ae01fb4b8c949c124b4a49b + 6d43da0bc3eae79d; + 560475cff206877de69146acc3ab6cf8556b7a + a776945948 + d1b8834df2196c92ec1718dcdeee0d52d9539726d2810391 + b3f9d10c39b07ae8f08ce7cee4758a386a9943e97dedfbe6 + 52df344f60bb655ce1efadd2bd8aadb58cba837a06a85693 + dfd8c77383ca55f1; + 1e737882cd09c2b9a80f34c0fde11c2481b11f + c76bfa4dbf71 + "" + 0a9e544e0c536ca1e040f9ad5b04140d98edabe08485290a4d87d13b07 + 8be902be354731e8231299e1b2dedaae4690ecf8089199e6cec95b6123 + 0f45a8eb852e5baa; + 398a1458c2c6b61dbdbc1cccada8c1a0a9aabb + 6c4e3c3554f8 + fb1ef61614c270295dfc0ca6551ca4bdb75359 + f91cb9d921056b7de74fc9a9b37154ce6c0b396179d31f06a1dd5982cb + 3fb468bbadc6a29bd6281da179066d2ade7be03df9c6b383c8e8c13546 + b26515dac888c01c; + c0d7cb23841da1ae8f4ae480cda98ad6cf2bacf6f9fd3f821330c4 + 3f3df6c2b3fa + "" + "" + "" + 34bd44dbfedfadb7; + c7cbcf96523d4723f91801325eb8553236651c96788d73d192ee53 + b3f3ebd66ddd + 98 + "" + "" + 30e8cb9e8b9c5270; + cedbe88e245de25b1593b70f8601562d90a9b59ed034a867642d25 + d54756fa5c47 + "" + f1 + 0b + a2ccd20dc938026f; + 6f64b837bb4926214211a1c696ba172010abb433922a22d9fd8815 + 19165e + "" + b9d85197a21cc34ac0d5ae7be8dbf98e4ffed2cf6b1372a5 + 68cd0332b59dd009fe414fedbaa6e5db5617a72662f17e00 + e56e28e0835cfe53; + aa47b54fd9d70c70e117bf1cae71b3a56f0e7d839ea59cc783443d + 64f2ed6a29 + b96856beca34fd6544bcf86b799e2a1681160ccf055f0fd3 + 001da597a1406d465b7b1419ea51cf858f938f6daafbd656 + 14eba6942ae06ed78cf099b84112f9a14ef047a66bc60759 + 8cf160f02394665d; + 445a09898eaa96ffc3d1d2e31e4e34c94b8bfae64825ecd75a66d8 + 8eedb969ffe0 + "" + 7669845ebb7a24c69f13d099f47166edf54538e88fbf433a7ff2120851 + 6d2c904a5679e677bb5388b0fd803942da8009ba69144d90adeebbbd9e + 9bc08b7a451dab64; + 79e79771f6eee7283ab178ef2b800d7b969da05780ffc1ba78c70d + da7a4ca2a25e + 771702fb1901ecfc8a959cb8e75079bb018ccc + 8c54f31b450e88f8e9002926ad0284c738f4cb0f58a1e34c8b15ad930c + 7e6523063d93c71b5e3843e7e1db47185be88cd6e59983a344ccaa55f3 + de2d08e85152d02e; +} + +rc2-ocb3-mct { + 16 cf8c7167477a5451; + 14 f7b6b2058ca5db46; + 12 249d762b7fef3e0a; + 10 a6d5f268d2dc063d; + 8 760827c7117d67ef; + 6 4acbb3854f8a4d2c; + 4 9165027bf9b60335; + 16 06ec3efc4156; + 14 0b3b19c5b0a6; + 12 8651074d6d12; + 10 f2c5ce719be9; + 8 d6646daf8e75; + 6 70c48ce7d192; + 4 61903ea2f3fe; + 16 a9049697; + 14 e4cdf5af; + 12 5571a44b; + 10 a9e735fa; + 8 4179cf26; + 6 4a83d2cf; + 4 f50be88c; +} diff --git a/symm/t/rc5 b/symm/t/rc5 index a70cc1ba..77daa317 100644 --- a/symm/t/rc5 +++ b/symm/t/rc5 @@ -727,3 +727,219 @@ rc5-pmac1 { e9002926ad0284c738f4cb0f58a1e34c8b15ad 27da50a416aca31c; } + +rc5-ocb3 { + 60d7bcda163547d348b7551195e77022907dd1dff7dac5c9941d26d0c6eb14ad568f86edd1dc9268eeee533285a6ed810c9b689daaa9060d2d4b6003062365b0a54364c76c160f11896c4794846ecfa14a7130c9f137120634c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e6057 + acc87638f508 + "" + "" + "" + 063c1bf330553d8c; + 046733d9ff61cdbda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93bf4f2aad2605faee2b03fb648e27fff63102758fe2b69ac26afa3349829b94586306fed54154f8f28523c03 + d4de16001578 + 46 + "" + "" + b6a770d618bfc1d7; + b710ee72807a2219bfb474fd71d891f24bb65d1563259f9eb53b571ea629c54d57dd2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f768281e040a9b9a222bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c037ba323fe1dc8151784873f0eb5b647da6794c18b5337685a96ed65b9aca338527ef19b09 + c063c46f88de + "" + 9f + 74 + 570a5073b8afc17f; + d41e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89d4b9b12012e4713df46795630e7952d22bb02d7100b8b649377d20a8f083455b663e4ee1315f3c8f2aebfa921451dcd1af5813b70d30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed12ca9 + 86981a + "" + 874498ad0abef8bc4fcb70e27e98ef1f0446b42fb144d44b + fa80154a33c295155643798240fd22d30613b2b6770a3327 + 31aca92d9606f720; + 6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb1c8dd0b00951f284649016ed00456331854bc78bf43966eb0cfa9138ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c04226f30cbb7f0e4a973a8cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e3fb90e1721b730374ffc9bc597f56ccbb2f294b38766fc + 69f6a9f2c0 + 945ffd505003cc0cae9ce021a5f1fa4ffa91544485f1a125 + 8b2b9b8f0911e32d65cc1770a18cbfe6effd1ff6778554ac + afeb6335d22d91e6027e219981fa6d22fa23d4170ee22c35 + 09e60a6bdcc1ba7f; + f1270485b203a3c1c4c967c0a458cb948bdd409b687fa3a6827b480aa3a4c84cef64f6c9b53bf8f957f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605ac8451399587011677508a15dde524af3e2bee0646541a42c2ecccb44d65bad397abfaf529ee41cf9a05c7efedef3401539c51d2a90bbf7f1bfc338ab0ef5746ea8fdcccd213e33f7e8a5718fd25014107 + c8e7d715a92a + "" + dd9589d1f5c054b2d983514605ec590294a319b9802068a9f891bc5ba5 + f29328c6d4104e0e1ef80cd7494957aad54f69ae2d1b95e1421c03f769 + 7d433a869031bf7e; + afabf8c3122d12d7ff3c41122d70d17d4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7abc8ad68daac90cfe22d2f1f2968cc42fa8b669ed3bb3542a9cf44bbc8c6254d980398bd94e66eb4563d405e51881e99027b8ab9aea3ccf860b0009740763d96836c5f87b95460938de1288c69d80ea12ff4bb5f069b8a2e86041c1b9fc214e9ca2186ddf1f6a7a3aa7e740d + a967828e3604 + b35b15ffaa6c36800d9645563a308ba6007681 + 7523bd2abf1261b089d8f23a9c2835076a23faac2cdd67771cc667a833 + d403996de8929a47a908bee11ffacc01a85f3d7af8c78ec0094a83e2ea + 10a662f856acdb4a; + 1f0a170b66283e4f834a06148f302c3973accd56f6f24e33958b8c2e2352fd61e4fa8fec816ac861a8b33779f09e7a10fc02a8f48afa3080ee119a52a9a817e4f2b94b0820cab383a8cffeea7c486315799dc875fba578c8ec4837898a92142b5b0677da1ac273117b45bcfff5d5f8b6fde2893232a9f81d14517ffae475f6b94a43a67b3d380d2f9aaafe2dd721c0095c8808847689211450ba8095ffab1eaadf66fd22ac1976063e113ab61f813e28a1397a7974a1d7f4220c785fe426a5a0e80f678d404147842941feeffdc2eb44dc8c0d5e8f444f7f4e0c893959 + b74dc23a7bb4 + "" + "" + "" + 4fa9e8d71758235e; + 0e7e0013e5150686d2301b43a15a84e81d7f5cedaa49e2414ebf47970e560475cff206877de69146acc3ab6cf8556b7aa776945948d1b8834df2196c92ec1718dcdeee0d52d9539726d2810391b3f9d10c39b07ae8f08ce7cee4758a386a9943e97dedfbe61e737882cd09c2b9a80f34c0fde11c2481b11fc76bfa4dbf710a9e544e0c536ca1e040f9ad5b04140d98edabe08485290a4d87d13b07398a1458c2c6b61dbdbc1cccada8c1a0a9aabb6c4e3c3554f8fb1ef61614c270295dfc0ca6551ca4bdb75359f91cb9d921056b7de74fc9a9b37154ce6c0b396179d3 + 1f06a1dd5982 + cb + "" + "" + bba7bb90cb237373; + c0d7cb23841da1ae8f4ae480cda98ad6cf2bacf6f9fd3f821330c43f3df6c2b3fac7cbcf96523d4723f91801325eb8553236651c96788d73d192ee53b3f3ebd66ddd98cedbe88e245de25b1593b70f8601562d90a9b59ed034a867642d25d54756fa5c47f16f64b837bb4926214211a1c696ba172010abb433922a22d9fd881519165eb9d85197a21cc34ac0d5ae7be8dbf98e4ffed2cf6b1372a5aa47b54fd9d70c70e117bf1cae71b3a56f0e7d839ea59cc783443d64f2ed6a29b96856beca34fd6544bcf86b799e2a1681160ccf055f0fd3001da597a1406d465b7b + 1419ea51cf85 + "" + 8f + fe + e5476d3424c2d40f; + 938f6daafbd656445a09898eaa96ffc3d1d2e31e4e34c94b8bfae64825ecd75a66d88eedb969ffe07669845ebb7a24c69f13d099f47166edf54538e88fbf433a7ff212085179e79771f6eee7283ab178ef2b800d7b969da05780ffc1ba78c70dda7a4ca2a25e771702fb1901ecfc8a959cb8e75079bb018ccc8c54f31b450e88f8e9002926ad0284c738f4cb0f58a1e34c8b15ad930c1b627235a2cb84241986c251f5b70be2367f047265264e0da72efe8995e6c932a17eab511eddb8e4ba463c663035a6ae8a7a899e4279d54d03f0e0f3e961dcfd40088d5be74088 + e4097e + "" + fb0368c7e2f431ee6988cf2a0e9ebeb3de79c4f86c9e4fba + 828b48b63905d7d298cf4f88d099cc209fe7483985517503 + 6bd18f02c7a6c90e; + 61339d6d907eab7707ca48ff5ba1ae93d16225d469de5747bc1addf5748729720a320fe14fd29cfc59314fe2079c0a2535ded56112d6e3d33dcf7c71cd7d130323794e3da84a9df69703a9caf02d2a8f57ac71e554a6850d55882f8c7ae6994fc8528bd18c374fc43581d2f72a89584a2404a059f7f99c7241a0c879d6d4455b382a9ce757b3e7a1d07585ad9d7ea9c7c9cf54f3bc6d94238ab56d738e02abd651477cd726d6f3ebcd6fadeab50906642a7de6496247060e7be3632ed9bd94bb42f45a8733b2cd2df9d1d905cfdb29983050d6bcdb686a0c897031ad09 + a5b8fa687e + c3bad8e18dc2ad361f1e226e78876cd35f86c639733c5cd8 + 4aed8aaebabb7e0f24edfd9710b7bca91b612ea37fc5cc09 + 0089fb21527fed153e81acdc9229d8341ca36df6ebdada9b + cc5b59ffe07eaff8; + f7f62f66b423fcd2dec5de24d264f2c839839c1b06319f687dbc68d9f07fd41ccb4f8cde8de201ec2680332bbded4883deea0b58b54bdd13c17ef292b0ded3caeb5e57fd21df10bc6186265ee6ea45907de6cb822fb2ef953aea358a03e0fce2e1b9511bd332c86e67f123377a8f0256b8dcc73ae1b3c6cd3f104e3cb24284cfed17811d64d492d39ea7496993a25b072945d83f923e66b0a6689cf0969c003a8fca80e322a4b1bf050c1220450433efb6b6d8a2d820cf27a64b9d47f636845dac557bb3e75f3a18fb8e173416867fcd0ee78ddd9236beec76d55ed58b + 10f91d07a037 + "" + 791ab96e83c4bf2fb5b205e592c172a5cbc19456c95c1bea6079f3867e + 0853cf3d4515b9e4b005c95fdddf3c74d4d3ccdaaa1015ae379b550302 + 2a56e4bba5f8d187; + 52d663cb3884b2a0a8ff825df752423f3179bfeb89eca385f20ddce5f1f23564672e370ffc37d400a31e8aac1d426ce10df73c5ee478b3b63d91024780e974a8a2a0e7a36f84ab1286b627e7d01b38a84a6de738721ed80fd0d7f69fa658abb5a440d304128719b541a9451cead18e4c61d93d1f8fcc53574427767396322b3bf7d02cec05093696cec07591ada462271b1d1519eedde0df37a330fe8c22ebd77705917b7e32ae88f45a34a8ba3037235e19a394be4d26ce47317d8087684456b4cfc5555e925e3e7b2ebc829b2d0505ea617b0ca9531bcdb96040d390 + 40e632d56264 + 3ccb64286303040fcaf679e914eaddc05af884 + 3ce6a427b99a5dc266de31c09165237eeefe4b58cc034b9f099f04678c + 48d32eec290f067c12f81697153f4030c56b1b79ffe695bc972ffda584 + 15d05287d12f9c8f; + 2a9da898b39324cd3087a651014f6796f9c4881d89e127e62221e47e57badd678d490c2f320ff8 + fb1c42761bd4 + "" + "" + "" + 19796de26b769f5b; + 39f3e96dc0ed1d5b2169912af1a4e2c533c52ba3e8c71c23a089e231480aa63c484fb34bd52239 + 7f102cb8ecf4 + f6 + "" + "" + 22f17895a971f1f3; + 4e329884fe73be257a753b38200bc23f94a079bde2dd98d813655dafa15b85419d15c41a5153cc + e5d0e8c8702d + "" + b2 + 6f + 511d62bc5b29da6c; + ba11927589678d4f7b8fcfad4818c411f15f452300903874f9a532ee46496ae753a2340af7b91f + 9632fc + "" + 5ae71ae18b40de751ab6b6761ca16434a9935e466e11c1cb + a60bb59c8292e00486962cb216e756dd66613fe9569e549d + ed2836258e0dfe45; + 072f32a59c313dba3db646ae909a096697d9a7b0556463ff1126ebc43263391424d02739d0787e + 804d8f1dcc + f6c897a8a48431324324041b5302ccd501b538bd03d5cb5c + 90d1fd3f7d2be187a787032c79ed900764ee4ce1d3fc042c + 84e43f8b78a4b759d7832084f4a43b94380155ead68222cf + 53e98d05afc28fb5; + 084f7d8c0c48ad7d6f1eabd0fd1ec24a88f26734d5c8d92dbd873a8fe113090d401bea4d28ff49 + f10ff593adc2 + "" + 58e091abd31b62dd1735158f98765970acc6602da063aae01a2a199d3a + ccad9333e858aba3b6be61d2821fc6485b94dee4fd3da0f24e18c5c8eb + befad9a49693a9ff; + 4f37a5f062d216d2053a83b5d3a0488ab0d2df631b2892cdfcf9fdd0f37de9ed67179aeae82fe0 + 0009428b297b + 553230a6d917fa0c1a233c9ebc8a4cba45b205 + 43c540fc1b9dbce078b87a1534acf03897b95a3f372e9f6c5a5f2ae44a + d4841df4923358d24721e29a4395fd8410f672286fb862f234d7afe446 + fbca241edc3784af; + 7dbce9ba43a39089de20de70d0544b5151db0a16e9769e8f2fc12c7f839fab269a0056284a697ffd4113a1cf43b5d5bdce2d86dead83f5a356e9106bedf908db61f1119f9700260ea9379cc723 + 2184d217158f + "" + "" + "" + a8dca51e818d1620; + ee8ca42e75614739e9007f234fbcd86b0ad8f641a0449b6d9b0f99d1cb4a57a4d6f987feb0ade90aa1d81c4f497b3734be301da3e25fe692629db57311f422f3a1573f9e0553a23e96265e4326 + fa532d713686 + 3e + "" + "" + 22724c59a99e8a28; + 5b4bc6c99ade3d4eb23cacdf6e42ad8ca13187eba1532920ba31582b3793b05fa65e9f80c5814b91f4d3c581c7b16c46b484859c6d19eebaf124681aa3be9943307fa4ef095ef8e7e50b703dc0 + 420e74227c93 + "" + 51 + cd + d31ba86abcc74ed5; + 366ef8e98e1e24b48aa989dbb8d0f10471ae5428a6012fbe4f5cb2dab2863e574842cc0b3774e00dcfa63b0db1716c7e916a26fc2e198f8db63ab59955989497782f16c5816270ef3fbe4ea22f + 484ddc + "" + 12ec8f4bdbd6ebdfbafb21fcf5427dbee5f95b53a0b4cb6d + 377776c7a23f367f4b797164000341b828e9af1528512d7e + 640622b80de68169; + 7c128b79f4657895f4b0ba518dd61436140f20d40224baac3a602da83cb254a7e03f052c63c1f3f00f301cc944a1789133bb8048f07dc123f2ca7e20c83988e4bfea6d561ab5aea542db544a14 + 376d5d52f7 + 265c7a8d2fc4feef99b9dba89eb472f71d8eb5affe900d77 + 6e4cf74e52b6c86db981143082735c6473a86a5da3d2e8cb + 96695b552838f18f1d0cdede1c6e8b7a94686a80d3faafb2 + 1b2ffe9cea3bdd6f; + b8602ebbaf08bf9315fba15f46714bfd2c8312fb5744dfe84615ddb93f15360161f2efb1fc39b8b6ad97427dcaa0435bee7f3a5c11fd01b9c120aa6004f84bcba838a1c33beb4087719135b355 + dce9ffd6fd63 + "" + 9f192e4c2c9a2752bf74a3f63408d3b27df51f44ed5537bfb0162f05ed + 15dacd515d731592ab85c1b5d9f3dbcde30179b31c493a15f6af916588 + 99a03f7a639d9ac1; + bad1b2c36ceec1dc407475b8e05fcb5ee66c7205f21804c3b73451dc9a3aed7667c6342c8355ff66b91eeffa115cf118eef301f2c93fda303878f7987116dba62d93a7da70274ffe5a6506e4e1 + 439de76cc9d3 + 32ab03510df3c7d35dc526b5b7785400f53d34 + b5d55fcac5fbeadd81456bbe6bcedb015be40bfbda656483b32fc4d0a9 + 82df9af04d4792ef8a746a950613ca561e9d1e395b28cd4efb20400d03 + b866935e219f4573; +} + +rc5-ocb3-mct { + 56 5d65dacd57c2aa33; + 52 03beeb48bcdb2c18; + 48 01d2c1abfdcd3689; + 44 4fe9063599fc965e; + 40 02c7d56243840c7c; + 36 b8835ac12d93de0c; + 32 c04dd9d0ccbc4df6; + 28 7d59856e20a6e739; + 24 8a1db814d18c6c97; + 20 99060d584b19a39f; + 16 722f822efb96b14b; + 12 20c08832fef3cccd; + 10 3bb20b4bb9ae613f; + 8 85f66ee439d96c46; + 56 f81750a75668; + 52 67fff337eefc; + 48 53149ad225e2; + 44 6cf6c8f56720; + 40 795b55a03080; + 36 a2aeb71e7493; + 32 4581768fa39c; + 28 e03e2ac2d905; + 24 f0c24fe14ad1; + 20 ba83f3fe63f0; + 16 c42c1512c9fe; + 12 d1934f3572cd; + 10 badab855071f; + 8 084797262a89; + 56 0c1bc6bd; + 52 805a3d32; + 48 9252506e; + 44 f848c865; + 40 f4a16d1d; + 36 57b79a09; + 32 e8b16e4b; + 28 a6a0961d; + 24 04dd92bc; + 20 8ca6413a; + 16 2b7d2d10; + 12 87440aab; + 10 3277a842; + 8 b84a6c79; +} diff --git a/symm/t/rijndael.local b/symm/t/rijndael.local index 9a1d2e62..e9517f14 100644 --- a/symm/t/rijndael.local +++ b/symm/t/rijndael.local @@ -1639,3 +1639,308 @@ rijndael-ocb2 { f75d6bc8b4dc8d66b836a2b08b32a6369f1cd3c5228d79fd6c267f5f6aa7b231c7dfb9d59951ae9c 65a92715a028acd4ae6aff4bfaa0d396; } + +rijndael-ocb3 { + ## Taken from RFC7253. + + 000102030405060708090a0b0c0d0e0f + bbaa99887766554433221100 + "" + "" + "" + 785407bfffc8ad9edcc5520ac9111ee6; + 000102030405060708090a0b0c0d0e0f + bbaa99887766554433221101 + 0001020304050607 + 0001020304050607 + 6820b3657b6f615a + 5725bda0d3b4eb3a257c9af1f8f03009; + 000102030405060708090a0b0c0d0e0f + bbaa99887766554433221102 + 0001020304050607 + "" + "" + 81017f8203f081277152fade694a0a00; + 000102030405060708090a0b0c0d0e0f + bbaa99887766554433221103 + "" + 0001020304050607 + 45dd69f8f5aae724 + 14054cd1f35d82760b2cd00d2f99bfa9; + 000102030405060708090a0b0c0d0e0f + bbaa99887766554433221104 + 000102030405060708090a0b0c0d0e0f + 000102030405060708090a0b0c0d0e0f + 571d535b60b277188be5147170a9a22c + 3ad7a4ff3835b8c5701c1ccec8fc3358; + 000102030405060708090a0b0c0d0e0f + bbaa99887766554433221105 + 000102030405060708090a0b0c0d0e0f + "" + "" + 8cf761b6902ef764462ad86498ca6b97; + 000102030405060708090a0b0c0d0e0f + bbaa99887766554433221106 + "" + 000102030405060708090a0b0c0d0e0f + 5ce88ec2e0692706a915c00aeb8b2396 + f40e1c743f52436bdf06d8fa1eca343d; + 000102030405060708090a0b0c0d0e0f + bbaa99887766554433221107 + 000102030405060708090a0b0c0d0e0f1011121314151617 + 000102030405060708090a0b0c0d0e0f1011121314151617 + 1ca2207308c87c010756104d8840ce1952f09673a448a122 + c92c62241051f57356d7f3c90bb0e07f; + 000102030405060708090a0b0c0d0e0f + bbaa99887766554433221108 + 000102030405060708090a0b0c0d0e0f1011121314151617 + "" + "" + 6dc225a071fc1b9f7c69f93b0f1e10de; + 000102030405060708090a0b0c0d0e0f + bbaa99887766554433221109 + "" + 000102030405060708090a0b0c0d0e0f1011121314151617 + 221bd0de7fa6fe993eccd769460a0af2d6cded0c395b1c3c + e725f32494b9f914d85c0b1eb38357ff; + 000102030405060708090a0b0c0d0e0f + bbaa9988776655443322110a + 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f + 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f + bd6f6c496201c69296c11efd138a467abd3c707924b964deaffc40319af5a485 + 40fbba186c5553c68ad9f592a79a4240; + 000102030405060708090a0b0c0d0e0f + bbaa9988776655443322110b + 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f + "" + "" + fe80690bee8a485d11f32965bc9d2a32; + 000102030405060708090a0b0c0d0e0f + bbaa9988776655443322110c + "" + 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f + 2942bfc773bda23cabc6acfd9bfd5835bd300f0973792ef46040c53f1432bcdf + b5e1dde3bc18a5f840b52e653444d5df; + 000102030405060708090a0b0c0d0e0f + bbaa9988776655443322110d + 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627 + 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627 + d5ca91748410c1751ff8a2f618255b68a0a12e093ff454606e59f9c1d0ddc54b65e8628e568bad7a + ed07ba06a4a69483a7035490c5769e60; + 000102030405060708090a0b0c0d0e0f + bbaa9988776655443322110e + 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627 + "" + "" + c5cd9d1850c141e358649994ee701b68; + 000102030405060708090a0b0c0d0e0f + bbaa9988776655443322110f + "" + 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627 + 4412923493c57d5de0d700f753cce0d1d2d95060122e9f15a5ddbfc5787e50b5cc55ee507bcb084e + 479ad363ac366b95a98ca5f3000b1479; + + 0f0e0d0c0b0a09080706050403020100 + bbaa9988776655443322110d + 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627 + 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627 + 1792a4e31e0755fb03e31b22116e6c2ddf9efd6e33d536f1a0124b0a55bae884ed93481529c76b6a + d0c515f4d1cdd4fdac4f02aa; + + ## More tests, made with the toy Python implementation. + 60d7bcda163547d348b7551195e77022 + 907dd1dff7dac5c9941d26d0c6eb + "" + "" + "" + 7d2702e740fddada3e57a788402f9d44; + 14ad568f86edd1dc9268eeee533285a6 + ed810c9b689daaa9060d2d4b6003 + 06 + "" + "" + c129582b8bd54dd2e80592f467112495; + 2365b0a54364c76c160f11896c479484 + 6ecfa14a7130c9f137120634c951 + "" + 98 + 8e + 27a9a3f75d1f36a156c714d820d0b3ed; + 48a877ff77bf79192a5b50ade5d9cd73 + 9a3d1f337f29549e6b0d27 + "" + a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e60 + fb544221d7bde1ec31564a9580440c902d76a7df1eff12955d17995e9bfe2336d4c2eeb42a6656dd37200ce5ff9cabfe + 0f9ff860aba97bfab2845af16558883f; + 57acc87638f508046733d9ff61cdbda3 + b3e9878731ebfedd4705e505da + 1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2fc5fa4 + 50727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54ef + 08584d252daf79311ca8d694e33e04711f723c890a222e7ce75ff2842e87e39d714934e8c6dc3640ffc5cdad1634063c + 679f104fe67c507aec33a0e15b589bc2; + c9a38378c5b93bf4f2aad2605faee2b0 + 3fb648e27fff63102758fe2b69ac + "" + 26afa3349829b94586306fed54154f8f28523c03d4de1600157846b710ee72807a2219bfb474fd71d891f24bb65d1563259f9eb53b + 63c2bf2254c696b288b0f41fb5b44bdf45914dce25d0071438069dbff337bc844506e5a47a28c700500280c08c54a5e4b43118ce36 + b9fde958caee8ea9cdbe8425ddb382ad; + 571ea629c54d57dd2d42f70800df9fcb + aca48b77dba189196d1ebba10b04 + 67cb9fc2712a199e533fa9156308cdec3f768281e040a9b9a222bd689aef66f5306ceb0c6b08ac8b0a2226 + 0c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c037ba323fe1dc8151784873f0eb5b647da6794c18b + a459d6659d827b523dabbc0a66cf8c151764b24a59199a6d8e4a161ace110c683dee759f823be08f0538fce282d036d2c7653ecb91 + 63bec719103775440457715faa831368; + 5337685a96ed65b9aca338527ef19b09c063c46f + 88de9fd41e72d7b97e23e6eabdff + "" + "" + "" + cc2b3f40254925c2e221259c3b6e8df2; + 3bcd211499268878dbf30f1dad89d4b9b12012e4 + 713df46795630e7952d22bb02d71 + 00 + "" + "" + 272e89e7297e08da41d775d62b336e80; + b8b649377d20a8f083455b663e4ee1315f3c8f2a + ebfa921451dcd1af5813b70d30ce + "" + 2f + cd + 3c1a46e21f59810999d3ef51f0460322; + 1fef6ef315d0798391805da08da3aefc5f8584b7 + c5e617669c0f16e39815d4 + "" + e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69 + b75d269e9b2a080fd4d34bf0f8e7007e289b3f84ae1b8b6635fe27c5121605f12ab038a2fdfe7e29128beb944fe01b4f + 0e98f9a81eb34cde7f67bf40e05b6058; + a4cd52147ed12ca986981a874498ad0abef8bc4f + cb70e27e98ef1f0446b42fb144 + d44b6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb1c8dd0b00951f284649016ed00 + 456331854bc78bf43966eb0cfa9138ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6 + a4b540f15bcf54450c71860ffb180accc2b9218e4780a80b11cda67f1c38c8a9a8b0c5d42b243c5007b1832868dc1212 + 9fdcf861176e933b53461b27aa00e837; + daa089c3f9099c5ffb824173d7634c04226f30cb + b7f0e4a973a8cd190107314717a7 + "" + 7456f3ff669c732b58db8f48af65f7cc9e3fb90e1721b730374ffc9bc597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003cc0c + 9897c9d1b74b1f19e984b37cfb2823670e662d5b26bc7216a174fe2bdc87b7ae8e76f57b71cf8ef83d9f7da96a5f470d6b29b62f06 + cf1f7c7135e2f593a2b66800fbf07ee8; + ae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f + 0911e32d65cc1770a18cbfe6effd + 1ff6778554acf1270485b203a3c1c4c967c0a458cb948bdd409b687fa3a6827b480aa3a4c84cef64f6c9b5 + 3bf8f957f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605ac8451 + 7df3a815613704e6db80308c5e5161430a724f4a11dee60f9b0519f96f29c8c6fcf91443f230d7ee8fd8206e0c71161e9d770d5586 + e54a174b4a61d1ee1faffa2dd7a59f70; + 399587011677508a15dde524af3e2bee0646541a42c2ecccb44d65ba + d397abfaf529ee41cf9a05c7efed + "" + "" + "" + 74e3172048a0aed02ad958e79920884b; + ef3401539c51d2a90bbf7f1bfc338ab0ef5746ea8fdcccd213e33f7e + 8a5718fd25014107c8e7d715a92a + dd + "" + "" + 148ca2d47df2264f1aba1b2b374aad1a; + 9589d1f5c054b2d983514605ec590294a319b9802068a9f891bc5ba5 + afabf8c3122d12d7ff3c41122d70 + "" + d1 + f5 + 4c185af3fa049730ff516d35fbda064d; + 7d4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7e + a2725cb2dac07ecde95759 + "" + ac46fee6dda7abc8ad68daac90cfe22d2f1f2968cc42fa8b669ed3bb3542a9cf44bbc8c6254d980398bd94e66eb4563d + 64e99a93b20ce72c4e9da3b335e722e85aeb922ace51720c32f4edb402571244d7d1e4f3d2bae1baa06da5ec6d7368ec + bd4509f46b03609bd11124376731fa19; + 405e51881e99027b8ab9aea3ccf860b0009740763d96836c5f87b954 + 60938de1288c69d80ea12ff4bb + 5f069b8a2e86041c1b9fc214e9ca2186ddf1f6a7a3aa7e740da967828e3604b35b15ffaa6c36800d9645563a308ba600 + 76817523bd2abf1261b089d8f23a9c2835076a23faac2cdd67771cc667a8331f0a170b66283e4f834a06148f302c3973 + ede69717cc474d94579f3aa442ecb523504280aa8dfb5604e81f8f18c5aee67140400e27ee7aa624cc3d2f8bd8eb1dc8 + e3472e0b88ee37919d72e8a29553274d; + accd56f6f24e33958b8c2e2352fd61e4fa8fec816ac861a8b33779f0 + 9e7a10fc02a8f48afa3080ee119a + "" + 52a9a817e4f2b94b0820cab383a8cffeea7c486315799dc875fba578c8ec4837898a92142b5b0677da1ac273117b45bcfff5d5f8b6 + 6ea42fed3a9e40ae5bd32e3513e027f791595675af5e77e0044070af2ce0ca4e1facf77f6b7f0c16b2c3c528343a9c7c6d1352517e + 476ce6884dfa2a97ce67aafcc3375ea6; + fde2893232a9f81d14517ffae475f6b94a43a67b3d380d2f9aaafe2d + d721c0095c8808847689211450ba + 8095ffab1eaadf66fd22ac1976063e113ab61f813e28a1397a7974a1d7f4220c785fe426a5a0e80f678d40 + 4147842941feeffdc2eb44dc8c0d5e8f444f7f4e0c893959b74dc23a7bb40e7e0013e5150686d2301b43a15a84e81d7f5cedaa49e2 + 17fa00469b04d4b9563e87be4bd5f9cffd0238adb9ee98938dabb0528e0fa95fc3cf499e67d4d19606242736d8e776bd5357a0d48c + c8ef4f4fccad46f7fb55786818991586; + 414ebf47970e560475cff206 + 877de69146acc3ab6cf8556b7aa7 + "" + "" + "" + 17c75f5f7d6d099a7d375b9ea6ee9fc6; + 76945948d1b8834df2196c92 + ec1718dcdeee0d52d9539726d281 + 03 + "" + "" + 2abbc7c4cac1b870f9e8a92f00f1f2f9; + 91b3f9d10c39b07ae8f08ce7 + cee4758a386a9943e97dedfbe61e + "" + 73 + f4 + 8ab448b5400b1a46c7c5e20ef9700e22; + 7882cd09c2b9a80f34c0fde1 + 1c2481b11fc76bfa4dbf71 + "" + 0a9e544e0c536ca1e040f9ad5b04140d98edabe08485290a4d87d13b07398a1458c2c6b61dbdbc1cccada8c1a0a9aabb + 7c8660ca8ca219cd98abe715c166df757edad193c7d1a6f9227d7633b1666bd34c86f6df7819a80903e5c37ffc5e0648 + 27c846118776e3626f15532888d3f887; + 6c4e3c3554f8fb1ef61614c2 + 70295dfc0ca6551ca4bdb75359 + f91cb9d921056b7de74fc9a9b37154ce6c0b396179d31f06a1dd5982cbc0d7cb23841da1ae8f4ae480cda98ad6cf2bac + f6f9fd3f821330c43f3df6c2b3fac7cbcf96523d4723f91801325eb8553236651c96788d73d192ee53b3f3ebd66ddd98 + 9c912ef9d07d26881c823aecb92e81cc988fbdd1292d49ae9cddc5c1fa5e1a618c96e71c64866481926bc83c1c2ec172 + b7f45c7b104609fc3be061ebb388ee13; + cedbe88e245de25b1593b70f + 8601562d90a9b59ed034a867642d + "" + 25d54756fa5c47f16f64b837bb4926214211a1c696ba172010abb433922a22d9fd881519165eb9d85197a21cc34ac0d5ae7be8dbf9 + 00bfa16e1410e13d46752a90f40b6d9f6193cf06930ecb55abd2f973b710fa0582b30f87e5edc850a652def300f06da79231471399 + b8858413846d2de7fa4654376b1b9f1f; + 8e4ffed2cf6b1372a5aa47b5 + 4fd9d70c70e117bf1cae71b3a56f + 0e7d839ea59cc783443d64f2ed6a29b96856beca34fd6544bcf86b799e2a1681160ccf055f0fd3001da597 + a1406d465b7b1419ea51cf858f938f6daafbd656445a09898eaa96ffc3d1d2e31e4e34c94b8bfae64825ecd75a66d88eedb969ffe0 + 9cadbe9441f1705005b73f4e5b1675fc77390306e768a3f599a8fb11846ec535f0fa52e88120d3409912c342401b16a395784c6dcc + 44773033baea19b7a13cfe0f67d9da85; +} + +rijndael-ocb3-mct { + 32 d90eb8e9c977c88b79dd793d7ffa161c; + 28 a3c8ceaa94b405effc970e05f15fa2ff; + 24 f673f2c3e7174aae7bae986ca9f29e17; + 20 c8bc484858c5b1bc9e4241e2f552b371; + 16 67e944d23256c5e0b6c61fa22fdf1ea2; + 12 2e9806312d331fe78476fe88afb74763; + 8 2cfce691258f4d0300c220a6ef4d0a81; + 4 5d36742a2f065dc845789585f81f052f; + 32 5458359ac23b0cba9e6330dd; + 28 a14417b0bad703c8d1eccd2e; + 24 05d56ead2752c86be6932c5e; + 20 a61001205f451947258a950d; + 16 77a3d8e73589158d25d01209; + 12 6a32e20692f16b31a51cff6d; + 8 211b29176d56d0528fd70c9f; + 4 db638b2ddc074fe1ec1056d3; + 32 7d4ea5d445501cbe; + 28 94d6f38a6bcf4fa0; + 24 0066bc6e0ef34e24; + 20 1a583bc011e8a4fc; + 16 192c9b7bd90ba06a; + 12 385bcd58e8387991; + 8 2fb22e566436473d; + 4 c00b55e9a2bed310; +} diff --git a/symm/t/rijndael192 b/symm/t/rijndael192 index e4f98a7e..4210f737 100644 --- a/symm/t/rijndael192 +++ b/symm/t/rijndael192 @@ -3596,3 +3596,217 @@ rijndael192-pmac1 { 9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c04226f30cbb7f0e4a973a8cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e d3653df2ff5ca70439d6f154551ba9ff27c5ead8db7af2a9; } + +rijndael192-ocb3 { + 60d7bcda163547d348b7551195e77022 + 907dd1dff7dac5c9941d26d0c6eb14ad568f86edd1dc + "" + "" + "" + b5d14574dad19385409d38eddbeb6afe08cbc6e40260f7c4; + 9268eeee533285a6ed810c9b689daaa9 + 060d2d4b6003062365b0a54364c76c160f11896c4794 + 84 + "" + "" + ff39389f60d0cb58841212408f59c1313e57029630808bbb; + 6ecfa14a7130c9f137120634c9519848 + a877ff77bf79192a5b50ade5d9cd739a3d1f337f2954 + "" + 9e + bc + af0809f4d9e7b23e1b98f8b65fd7326aa8b546065218757e; + 6b0d27a4ba234085406a6136512061f7 + 080cc07df0591d8fa21f2dd88374d8cde8e160 + "" + ad10997a21635c6d62c9269029df3e6057acc87638f508046733d9ff61cdbda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533 + 0fd527536eda95bc7b5e1e67c5737626da7251fb0bb540e3a684656d29c7ee45e19d670d8c7a8a896633608aedb539b5e42d5d9d8d05320777dac9687207f733f137f64a36940ffc + e8df4fd3fac5b4b10a2242cc5ddf436f8acac68e0700dffb; + 966f27043eb621b7f65b000961040ef2 + f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f + 215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93bf4f2aad2605faee2b03fb648e27fff63102758fe2b69ac26afa3349829b9458630 + 6fed54154f8f28523c03d4de1600157846b710ee72807a2219bfb474fd71d891f24bb65d1563259f9eb53b571ea629c54d57dd2d42f70800df9fcbaca48b77dba189196d1ebba10b + 715f3c2b119bc11bd4723df66915752c925e89e5652090168877845f6a5cf40c032b3a54887cf0cbae47edd7623c876a2e3c2035d0dacd42a8820bbd7a20d4991b3c8a98ad7d8331 + 1b8c5703782c163b28509cb1cb67e2e0bdaf949867dc63d4; + 0467cb9fc2712a199e533fa9156308cd + ec3f768281e040a9b9a222bd689aef66f5306ceb0c6b + "" + 08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c037ba323fe1dc8151784873f0eb5b647da6794c18b5337685a96ed65b9aca338527ef19b09c063 + fe808b32e6844a1ae334b145183e092c6c18eec5268104868889f5e9f197a831ebea245adb9ead21c16461918a5b48f33720884758d98a55380fb9c088c60a120402a336a646f2499d44e59e44 + 455d8abc815b66b77c0c7b048215508a1420d501c6caffb3; + c46f88de9fd41e72d7b97e23e6eabdff + 3bcd211499268878dbf30f1dad89d4b9b12012e4713d + f46795630e7952d22bb02d7100b8b649377d20a8f083455b663e4ee1315f3c8f2aebfa921451dcd1af5813b70d30ce2f1fef6ef315d0798391805da08da3aefc5f8584 + b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed12ca986981a874498ad0abe + 1c8d47ef199e6fb28c25a07ae8051b0785c73579e224b9e85990c66628a3e2a1f21e26735a47c3df4563c23c0e2814fa708566948113cca1fddecf2109c56dacd260689b45c72cedc522b593c8 + 652c3473b278ac660297c275b0a7beb9501c0d8654310b3f; + f8bc4fcb70e27e98ef1f0446b42fb144d44b6d00 + f06dc188d472a784e0c6f21195a3b9f4ae985511265f + "" + "" + "" + b0b54530145be3e9ba77f97799d7a386747f260b20c71d4c; + ebd11c164720eef9eb1c8dd0b00951f284649016 + ed00456331854bc78bf43966eb0cfa9138ddc3990844 + 56 + "" + "" + a7544f3687f32006a57591900a0a73224133ccea2e6c705d; + 08fe95e81c2533e31c9c1a9851bc2810d858cbbc + 8424d126b807e6daa089c3f9099c5ffb824173d7634c + "" + 04 + 7e + 13f61abd0de5586dc8a054920b885d81a075db59807b3de0; + 226f30cbb7f0e4a973a8cd190107314717a77456 + f3ff669c732b58db8f48af65f7cc9e3fb90e17 + "" + 21b730374ffc9bc597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003cc0cae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f0911e32d65cc1770a18cbfe6effd1ff6778554ac + f67230d596aba65ecb5d1708bf3eea0c2b8adf346fdb033f4c6dbc9e1b1a394353d4d054ceecf6cc9fd93487da8a5c70feadd5067c9b20dd5096418c2b1d96de1c24ffd51d6c376f + 4e72953575d116de1f5283af168f6c9e93abd250d36e966c; + f1270485b203a3c1c4c967c0a458cb948bdd409b + 687fa3a6827b480aa3a4c84cef64f6c9b53bf8f957 + f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605ac8451399587011677508a15dde524af3e2bee0646541a42c2ec + ccb44d65bad397abfaf529ee41cf9a05c7efedef3401539c51d2a90bbf7f1bfc338ab0ef5746ea8fdcccd213e33f7e8a5718fd25014107c8e7d715a92add9589d1f5c054b2d98351 + ee2b2fc312e954332969db113f066c2ca26a2a521308ed891cae549afdc3198d1c1e154c73a675cc74e893c95a0e52473ffc15b5540339b3b3a5e62bd36be0e08c5d313d2a1e8cf1 + a7001eb1a36d838c1425c07ba29c9f8914094e5cad71bbf4; + 4605ec590294a319b9802068a9f891bc5ba5afab + f8c3122d12d7ff3c41122d70d17d4569eaff59a332ba + "" + 58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7abc8ad68daac90cfe22d2f1f2968cc42fa8b669ed3bb3542a9cf44bbc8c6254d980398bd94e66eb456 + 1411b2dc14e6fa752fa2092a36657ebf4e742ad3f74267c6804dd6e9b508c526639d7ade46a49af597966bd5c4cb83ca831f638214498d700b7b52512e7d1fdb1e2e4443d5f2e110901730461c + eee75d53b2357e78a5b5aaea134f60f48bcc4a6d0f5c8998; + 3d405e51881e99027b8ab9aea3ccf860b0009740 + 763d96836c5f87b95460938de1288c69d80ea12ff4bb + 5f069b8a2e86041c1b9fc214e9ca2186ddf1f6a7a3aa7e740da967828e3604b35b15ffaa6c36800d9645563a308ba60076817523bd2abf1261b089d8f23a9c2835076a + 23faac2cdd67771cc667a8331f0a170b66283e4f834a06148f302c3973accd56f6f24e33958b8c2e2352fd61e4fa8fec816ac861a8b33779f09e7a10fc02a8f48afa3080ee119a52a9a817e4f2 + c4a9eeb3f04799ce6944e8104509fa1aef8f17b5815ba391c356d895d7cf996513eed08a74f58e01e534f0f5c3079c770e255a9278fbe8a3da967a01d5536b1a87292db733862f4f98304a7307 + 0dbf831632cb781a3ec5c78d99e363ff3e7dfa646fd9e90c; + b94b0820cab383a8cffeea7c486315799dc875fba578c8ec4837898a + 92142b5b0677da1ac273117b45bcfff5d5f8b6fde289 + "" + "" + "" + ed4dee5d2f4f878178ede9ff462515501765dd09987f4957; + 3232a9f81d14517ffae475f6b94a43a67b3d380d2f9aaafe2dd721c0 + 095c8808847689211450ba8095ffab1eaadf66fd22ac + 19 + "" + "" + 2157ffb54f20ad64b0ae17d72c99dcc7f14093b49121bb30; + 76063e113ab61f813e28a1397a7974a1d7f4220c785fe426a5a0e80f + 678d404147842941feeffdc2eb44dc8c0d5e8f444f7f + "" + 4e + b8 + 0f3e95269af57fd63b09cac38f5c5f0934a752201dff056b; + 0c893959b74dc23a7bb40e7e0013e5150686d2301b43a15a84e81d7f + 5cedaa49e2414ebf47970e560475cff206877d + "" + e69146acc3ab6cf8556b7aa776945948d1b8834df2196c92ec1718dcdeee0d52d9539726d2810391b3f9d10c39b07ae8f08ce7cee4758a386a9943e97dedfbe61e737882cd09c2b9 + 60b0cded984a7111026de06190745d65af6942a64b7561ae21f68d213ad0ad22ac6fe56c8b7dd756cd9bf6ba13c2c011cd99387ebae0422a4e12e11ceafb0292de2097a876e5c416 + b28761e6f95f1faef3e4203ed6bc359c0406982b19d8a6d0; + a80f34c0fde11c2481b11fc76bfa4dbf710a9e544e0c536ca1e040f9 + ad5b04140d98edabe08485290a4d87d13b07398a14 + 58c2c6b61dbdbc1cccada8c1a0a9aabb6c4e3c3554f8fb1ef61614c270295dfc0ca6551ca4bdb75359f91cb9d921056b7de74fc9a9b37154ce6c0b396179d31f06a1dd5982cbc0d7 + cb23841da1ae8f4ae480cda98ad6cf2bacf6f9fd3f821330c43f3df6c2b3fac7cbcf96523d4723f91801325eb8553236651c96788d73d192ee53b3f3ebd66ddd98cedbe88e245de2 + 76214c8de16aa91bb77876d7975b49cc15da1a63487133994bda609099c60d7f0d2bbb2efd5af7dc3a276a56220004edc7b1da45c6164d91d77772ed91d587b9caadd20e27d078db + 38e894b028899b17056bc987b2ba8fbd7cd6d0cc4a50fb38; + 5b1593b70f8601562d90a9b59ed034a867642d25d54756fa5c47f16f + 64b837bb4926214211a1c696ba172010abb433922a22 + "" + d9fd881519165eb9d85197a21cc34ac0d5ae7be8dbf98e4ffed2cf6b1372a5aa47b54fd9d70c70e117bf1cae71b3a56f0e7d839ea59cc783443d64f2ed6a29b96856beca34fd6544bcf86b799e + c84c85f543c7f56134b2b5e0a48c384ee52d231d0706b2524d39cad86d4e02c085d3c95f96e0e4bb5189376b5276d0a7bdf6b554d92c8984168596abebea609707fad78cd0ebfd0968823854f2 + 04a3929311c62ac5a52e41328632178462d078e4a495a115; + 2a1681160ccf055f0fd3001da597a1406d465b7b1419ea51cf858f93 + 8f6daafbd656445a09898eaa96ffc3d1d2e31e4e34c9 + 4b8bfae64825ecd75a66d88eedb969ffe07669845ebb7a24c69f13d099f47166edf54538e88fbf433a7ff212085179e79771f6eee7283ab178ef2b800d7b969da05780 + ffc1ba78c70dda7a4ca2a25e771702fb1901ecfc8a959cb8e75079bb018ccc8c54f31b450e88f8e9002926ad0284c738f4cb0f58a1e34c8b15ad930c1b627235a2cb84241986c251f5b70be236 + 7f46b1b9de6077c8ec8d7a07c53c4efe4a7fc60cb8de683164df9faf4b4bd540b6076f4f8449f215ebcb17f73ad9d2d92930e0134be8a56fca74f0f945100425438085e7b3994752a100db09d7 + 8465609210664b702ba7297e945027461069d9dab09c8ada; + 7f047265264e0da72efe8995 + e6c932a17eab511eddb8e4ba463c663035a6ae8a7a89 + "" + "" + "" + 867ef0e4e4136a82e85c2ac3a7d6caa7a0c4789af22df032; + 9e4279d54d03f0e0f3e961dc + fd40088d5be74088e4097efb0368c7e2f431ee6988cf + 2a + "" + "" + 9d88b7a1abb6dbaa577fb9032334094d426045ac2b848598; + 0e9ebeb3de79c4f86c9e4fba + 61339d6d907eab7707ca48ff5ba1ae93d16225d469de + "" + 57 + eb + af67bb55608d1620c17ca5404cd788d4eb6c738d9597fd13; + 47bc1addf5748729720a320f + e14fd29cfc59314fe2079c0a2535ded56112d6 + "" + e3d33dcf7c71cd7d130323794e3da84a9df69703a9caf02d2a8f57ac71e554a6850d55882f8c7ae6994fc8528bd18c374fc43581d2f72a89584a2404a059f7f99c7241a0c879d6d4 + d72178266c9c112c4618e31aa17d1b48ccb51963204539bb07ef387a95454f43c4131e65c1fc4cc28ce70666995d4c86b69f4031edd9abe6e71b27270d75e6c786282401e38bcce4 + a9b01accbdfccd6b65c684d04a9c836de6b7377c93f066b4; + 455b382a9ce757b3e7a1d075 + 85ad9d7ea9c7c9cf54f3bc6d94238ab56d738e02ab + d651477cd726d6f3ebcd6fadeab50906642a7de6496247060e7be3632ed9bd94bb42f45a8733b2cd2df9d1d905cfdb29983050d6bcdb686a0c897031ad09a5b8fa687ec3bad8e18d + c2ad361f1e226e78876cd35f86c639733c5cd84aed8aaebabb7e0f24edfd9710b7bca91b612ea37fc5cc09f7f62f66b423fcd2dec5de24d264f2c839839c1b06319f687dbc68d9f0 + 598a1235709ceae2308d4c08c0bb6019a8797608d983e6701893d983b7574662a7790da0d68b07299907272fe218cbd19549cc10b1aee2f70c23b1825f734c222369929d78780ed8 + f8998bcc33440204eb8abe0ae0a50dfc6d59eac76ea51cf6; + 7fd41ccb4f8cde8de201ec26 + 80332bbded4883deea0b58b54bdd13c17ef292b0ded3 + "" + caeb5e57fd21df10bc6186265ee6ea45907de6cb822fb2ef953aea358a03e0fce2e1b9511bd332c86e67f123377a8f0256b8dcc73ae1b3c6cd3f104e3cb24284cfed17811d64d492d39ea74969 + d66d4a577c1df9ddc37036d5ba8206a6ae9b59bd7d9f096c4184be067aa8c6f836251fd1187edeca358a375cad0bd2ab89563978941870552c94faf821971f77c1583e51fd5077f32b9b5bfd0f + 1f839690aead572ae9fd15ee968983dd34fb8dbd4e5827be; + 93a25b072945d83f923e66b0 + a6689cf0969c003a8fca80e322a4b1bf050c12204504 + 33efb6b6d8a2d820cf27a64b9d47f636845dac557bb3e75f3a18fb8e173416867fcd0ee78ddd9236beec76d55ed58b10f91d07a037791ab96e83c4bf2fb5b205e592c1 + 72a5cbc19456c95c1bea6079f3867e52d663cb3884b2a0a8ff825df752423f3179bfeb89eca385f20ddce5f1f23564672e370ffc37d400a31e8aac1d426ce10df73c5ee478b3b63d91024780e9 + 5ccb483f688309a92fdd49b62e82cd6eba809cc87085e08037d2ec45b51db4dee112b3733a650f1ef167d684e5fa46e62ebd7002433c0022874a5839bc57b13f41ac3d221d0ec3d6f727fd1a8f + ab66a6b01196d8dd216791da419b5cf132788abed4254d85; +} + +rijndael192-ocb3-mct { + 32 9f02c63dd249efeb7f4d8453ee3c38cfc9930a7ef42faf68; + 28 abd57fc930c095eec2d8cc466a26ed96ee9b4ce00bc02b32; + 24 ff3b3dd8e0f774136f01351375c53605687c0626f0456253; + 20 c05ef316f4452a992aebedc3565760cd61dbc635db5b01b2; + 16 3e89734e70fa99dbe1571178aa1edb917330932a2ff6ac64; + 12 7506243a5da5b0cfccec7138bdd6139fe41407bbb5b410e1; + 8 e6aad44d2d891651052c6b1386bb10b5fb782976df1c1e70; + 4 6ddb5a25933d8061b4e5e77ec3cd10680308a5dcad517385; + 32 906dddd0884c542b133dff61c61f2162e9d95b10; + 28 33d3e253c75e411ceeee00c9a0210f7c712ecd66; + 24 859cbce898522f5b8722d39fd102288559711820; + 20 1d323ad20a20660b568279370228800d724d4c64; + 16 7604277e9535634d8a43f77a051914760fba923f; + 12 a144bd8fac2616e541c222cb1d8fa1937901dff8; + 8 9e4c1fb5aabf111ecb49545a92dc91449345ec77; + 4 b2a77eed505ca3ba5edc1a95cac166b02f7ca515; + 32 52b3de9c9a0e7a7f3f65170a59a0a959; + 28 925abc1d13cf9aa5c0fbcf73ac78b559; + 24 08db50d58b2e97c2931e231775fbabae; + 20 1c154b77e569e62ff13603a6397bf88b; + 16 a514526ab5a5f5622632bf8dbb009f74; + 12 1b483b245d9c11c1ad947a74f7303b27; + 8 ec31ba263ee64ec9f0e4ff4d7a2498f3; + 4 dcaee7b3276238b3d9c946ea970d823c; + 32 f43eb7ac65b4f6cc7ef4c1ef; + 28 ffdeff14896db787f8b9a8cc; + 24 e3d0eec8426fb7223622eed6; + 20 7b9b29ffe3f2de6b85b2f542; + 16 4a5928e2406cf876486539d6; + 12 e1a51d35431662bd48c8d4be; + 8 3fcc5d9987661e00bbe41201; + 4 c5a4cebe92b555fe8a3bdad7; + 32 dce58465343f136e; + 28 6ce50ed44f5d41f1; + 24 876ecff3404f371b; + 20 605b7adeef15c3f8; + 16 a56e57ee9e8f5130; + 12 48ebd3b98cbda23c; + 8 c34363871760230a; + 4 484de0d92485471c; +} diff --git a/symm/t/rijndael256 b/symm/t/rijndael256 index fc5a33e9..803b2d6c 100644 --- a/symm/t/rijndael256 +++ b/symm/t/rijndael256 @@ -3609,3 +3609,217 @@ rijndael256-pmac1 { 7b480aa3a4c84cef64f6c9b53bf8f957f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605ac8451399587011677508a15dde524af3e2bee0646541a42c2ecccb44d 631ff4d45f8f6536dbc36c29a857d440c7769e87829b468e051e0de73f82940a; } + +rijndael256-ocb3 { + 60d7bcda163547d348b7551195e77022 + 907dd1dff7dac5c9941d26d0c6eb14ad568f86edd1dc9268eeee533285a6 + "" + "" + "" + 94cd6ce38b3c77d05a0a0d25c295a65a6b7d7dfe954b0cefac92134d2864832b; + ed810c9b689daaa9060d2d4b60030623 + 65b0a54364c76c160f11896c4794846ecfa14a7130c9f137120634c95198 + 48 + "" + "" + 405c363c87384173bb83480d788161af11844656e9cef376f25b82bb5e1c537f; + a877ff77bf79192a5b50ade5d9cd739a + 3d1f337f29549e6b0d27a4ba234085406a6136512061f7080cc07df0591d + "" + 8f + 0f + 66d804966f42b17b54de7c5c83254b129c4ceb4a428c76c4d8d06cc3efa3108d; + a21f2dd88374d8cde8e160ad10997a21 + 635c6d62c9269029df3e6057acc87638f508046733d9ff61cdbda3 + "" + b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a4803037 + 874bd486ad241e305a5a00887137d77528095262228eb73fd52f1c6e6313600da01bf461d676730308c2c61feb98f1cda079b3b4372c6c3871c434c75972bb12fabfd29bb6253fc54ba1b93a30fd2bbb0d8552886c324a268afc3049aec44900 + 5913eb9194f12a3cf55bc082c9dc16ea94539318585e88fb31cb62f6732e7004; + 0c33d090c54215abd6b3ad54efc9a383 + 78c5b93bf4f2aad2605faee2b03fb648e27fff63102758fe2b69ac26af + a3349829b94586306fed54154f8f28523c03d4de1600157846b710ee72807a2219bfb474fd71d891f24bb65d1563259f9eb53b571ea629c54d57dd2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cd + ec3f768281e040a9b9a222bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c037ba323fe1dc8151784873f0eb5b647da6794c18b5337685a96ed65b9aca338527ef19b + 0ff57de3d2cc21519dd3d0f49fda28b2b5be55e284d48d36e5cba568ae1e8b58fa124c37912109af141b0f186c2fa348b62ca46c66b6889aefe7d2feb01a0379069e051ef893b2a1b40d67aa04b99c53ceda7b3bcd2b7981638e4d8a319e8283 + 68dbfe675410e257abc994d87e0d6b3285ef039f4296e4a3ef6c3380e8b9d057; + 09c063c46f88de9fd41e72d7b97e23e6 + eabdff3bcd211499268878dbf30f1dad89d4b9b12012e4713df46795630e + "" + 7952d22bb02d7100b8b649377d20a8f083455b663e4ee1315f3c8f2aebfa921451dcd1af5813b70d30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c + c5cbe3643d4234720636c3db98390cf32199996b8ce59bc07885a360d5cfd002cdf9be271301983a242a71f966668b54deb6cc8e602c11b4db33b0ef65437bfdf4a92d0f923f9997c3c74c3d850b8a485615e0b50b07f76cb252602bf211492cc980113905 + 5470a7b06cc51ec77c63446ca423d3153633f1957329423be3a685b42981dea2; + 31e6bc58c0b7cadcb658b970e47479a6 + 84b5aefa69a4cd52147ed12ca986981a874498ad0abef8bc4fcb70e27e98 + ef1f0446b42fb144d44b6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb1c8dd0b00951f284649016ed00456331854bc78bf43966eb0cfa9138ddc39908445608fe95e81c2533e31c9c1a9851bc + 2810d858cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c04226f30cbb7f0e4a973a8cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e3fb90e1721b730374ffc9bc597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003cc0cae + 870e6e1f56383e064accc0744f1b450d79455adbc72e49461ba13564ccf944450db7425db27c41f82bb0a36397116c2cd1a1034920fa12bdc9d6fc62cedef298195a8e05dd34cdef1726048ee2d8c9ab7d5f46f8c9446baf704c7755f3ee8d91a6fe91b14b + 67d3c0473bc44d9ab3f05eb918cb7161773a63428d9d399854041d31168df643; + 9ce021a5f1fa4ffa91544485f1a1258b2b9b8f09 + 11e32d65cc1770a18cbfe6effd1ff6778554acf1270485b203a3c1c4c967 + "" + "" + "" + 220a303425f9a53ce13518047d3dd5d8a1d2109ac835eceb441c5a586185f99a; + c0a458cb948bdd409b687fa3a6827b480aa3a4c8 + 4cef64f6c9b53bf8f957f4b03cf43e89957f9a3e8128f8743d16687b7bb8 + de + "" + "" + 7c5abcd9e9323820d615abf862549cc31c1b4e1a1e4da3e5433ba6e39e5bf538; + b9bd205b70e04c091d205cdad9e9a79b1abf91b0 + 851e5ca605ac8451399587011677508a15dde524af3e2bee0646541a42c2 + "" + ec + a0 + 3fce0fc48d3f0d7643ebeed0d4717eaaec3f4e2dfdff01a8785fb143e532f5a5; + ccb44d65bad397abfaf529ee41cf9a05c7efedef + 3401539c51d2a90bbf7f1bfc338ab0ef5746ea8fdcccd213e33f7e + "" + 8a5718fd25014107c8e7d715a92add9589d1f5c054b2d983514605ec590294a319b9802068a9f891bc5ba5afabf8c3122d12d7ff3c41122d70d17d4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde957 + 61bc90511fe93f33ef7e6ab4413c9a0316b1c5ed6f08f6b01242a31e226cf226df4af92db146356f1085cca26df2fc170b84f4b8106ecf2d83fad1572c3be1c30bdbf150035a6133b3ca54639084608bcd0aad6999675b63f2550129a01dee57 + 3310b19ecff1df1ec1e41c327a823ad057d4f4f494a867a029f27be5f9c540c2; + 59ac46fee6dda7abc8ad68daac90cfe22d2f1f29 + 68cc42fa8b669ed3bb3542a9cf44bbc8c6254d980398bd94e66eb4563d + 405e51881e99027b8ab9aea3ccf860b0009740763d96836c5f87b95460938de1288c69d80ea12ff4bb5f069b8a2e86041c1b9fc214e9ca2186ddf1f6a7a3aa7e740da967828e3604b35b15ffaa6c36800d9645563a308ba60076817523bd2abf + 1261b089d8f23a9c2835076a23faac2cdd67771cc667a8331f0a170b66283e4f834a06148f302c3973accd56f6f24e33958b8c2e2352fd61e4fa8fec816ac861a8b33779f09e7a10fc02a8f48afa3080ee119a52a9a817e4f2b94b0820cab383 + 134807254d64c7724ed92cdad040f7f59a768628d3d57c45bd3eceae504854100ec839b7c3ccac4e6644fad7812fc05834435d690b67bedb6f4801c9c4ae2d8fbfb1c879e6546e6db284071ed8ffb46ea8969dd3ca48cf3872c1a7d80ceb46c8 + b379c41bb4390d6908cfe111a9dd6dcc768b040ffe4af315f3cef5e0aa8c86c8; + a8cffeea7c486315799dc875fba578c8ec483789 + 8a92142b5b0677da1ac273117b45bcfff5d5f8b6fde2893232a9f81d1451 + "" + 7ffae475f6b94a43a67b3d380d2f9aaafe2dd721c0095c8808847689211450ba8095ffab1eaadf66fd22ac1976063e113ab61f813e28a1397a7974a1d7f4220c785fe426a5a0e80f678d404147842941feeffdc2eb44dc8c0d5e8f444f7f4e0c893959b74d + 7b5de357d72bd4a66e08bdf26b45f5d47e4c4042b89c239682d74e9bb1cd0f544aae03e377c97b30688249beb16e2e43d82c7761d7e61ceb853ad2209c68b405e99283fac3df1c6c2dd8222a9adcfbe909f0fcd81692e36a49b04dc2b1841f26145fcf57d6 + dd6d1166ec2c7975dcdb49e29a3d55ae62fd37726266e884efea710157757b61; + c23a7bb40e7e0013e5150686d2301b43a15a84e8 + 1d7f5cedaa49e2414ebf47970e560475cff206877de69146acc3ab6cf855 + 6b7aa776945948d1b8834df2196c92ec1718dcdeee0d52d9539726d2810391b3f9d10c39b07ae8f08ce7cee4758a386a9943e97dedfbe61e737882cd09c2b9a80f34c0fde11c2481b11fc76bfa4dbf710a9e544e0c536ca1e040f9 + ad5b04140d98edabe08485290a4d87d13b07398a1458c2c6b61dbdbc1cccada8c1a0a9aabb6c4e3c3554f8fb1ef61614c270295dfc0ca6551ca4bdb75359f91cb9d921056b7de74fc9a9b37154ce6c0b396179d31f06a1dd5982cbc0d7cb23841da1ae8f4a + 8257b8b269a4660300f762471821ca7a83d067b72aba369efa0edf5900693daee8da585e8f41aacde010cb5efbec25bd2ad47c1112f5ae87f79180659f3eb86052d760392fd1a268c2e75ad6e6dc447f5581fbd2aaf41bf7120c169688c8043b3db9f8fc1c + 3d62bf30f4aca83ca3198e4d91e2ac40c9c6e5be1f6e02943f0a947022425d5b; + e480cda98ad6cf2bacf6f9fd3f821330c43f3df6c2b3fac7cbcf9652 + 3d4723f91801325eb8553236651c96788d73d192ee53b3f3ebd66ddd98ce + "" + "" + "" + 5f89715a1b8c7fb4fd3816b482fecf863fd5ffd013258827030d840fa2d2a1d7; + dbe88e245de25b1593b70f8601562d90a9b59ed034a867642d25d547 + 56fa5c47f16f64b837bb4926214211a1c696ba172010abb433922a22d9fd + 88 + "" + "" + 065b3d824cbbad977cf67a74c2dcdf3605309d86ab3df633aa3ab27347e44e82; + 1519165eb9d85197a21cc34ac0d5ae7be8dbf98e4ffed2cf6b1372a5 + aa47b54fd9d70c70e117bf1cae71b3a56f0e7d839ea59cc783443d64f2ed + "" + 6a + 69 + 9a88da0ce1b21c5c7ca8badc6b9e8e59ed577ac39b0af14fdab20b02dc9df442; + 29b96856beca34fd6544bcf86b799e2a1681160ccf055f0fd3001da5 + 97a1406d465b7b1419ea51cf858f938f6daafbd656445a09898eaa + "" + 96ffc3d1d2e31e4e34c94b8bfae64825ecd75a66d88eedb969ffe07669845ebb7a24c69f13d099f47166edf54538e88fbf433a7ff212085179e79771f6eee7283ab178ef2b800d7b969da05780ffc1ba78c70dda7a4ca2a25e771702fb1901ec + e3e73214e48c0326b4e390a35aa9c0d9a8696a196543c3bf9409f2675fedcb4b5b369ec744fcb5d2ee7a5e76549f1f9e2a7c98b1989349e37e82bed729c9278ef0a925fdc7c838535dfe0351f8d7b3be579c9b17382ab0720513ea9c485097c6 + ef9f792e7eff79fb841852ed80cb6b30429520d077bbedde0d797735230dca6d; + fc8a959cb8e75079bb018ccc8c54f31b450e88f8e9002926ad0284c7 + 38f4cb0f58a1e34c8b15ad930c1b627235a2cb84241986c251f5b70be2 + 367f047265264e0da72efe8995e6c932a17eab511eddb8e4ba463c663035a6ae8a7a899e4279d54d03f0e0f3e961dcfd40088d5be74088e4097efb0368c7e2f431ee6988cf2a0e9ebeb3de79c4f86c9e4fba61339d6d907eab7707ca48ff5ba1 + ae93d16225d469de5747bc1addf5748729720a320fe14fd29cfc59314fe2079c0a2535ded56112d6e3d33dcf7c71cd7d130323794e3da84a9df69703a9caf02d2a8f57ac71e554a6850d55882f8c7ae6994fc8528bd18c374fc43581d2f72a89 + 17bd1896ca1775f27a78f55e568ac95360963aa799f1736346c94174b2749d9626a2d11af0a3717f4ddd4bb7d71c27c834cc11973300b851590c28bc90e377b9c672be42329e4fdc2b8178f54727f529d6c6c973ffef4bc3d829df42e2913d93 + 0666959b0610c0e4390049ff5339e64bf450a485947e7ced421550d5b4237143; + 584a2404a059f7f99c7241a0c879d6d4455b382a9ce757b3e7a1d075 + 85ad9d7ea9c7c9cf54f3bc6d94238ab56d738e02abd651477cd726d6f3eb + "" + cd6fadeab50906642a7de6496247060e7be3632ed9bd94bb42f45a8733b2cd2df9d1d905cfdb29983050d6bcdb686a0c897031ad09a5b8fa687ec3bad8e18dc2ad361f1e226e78876cd35f86c639733c5cd84aed8aaebabb7e0f24edfd9710b7bca91b612e + d98615675232b1e3b446b8ef49645238f92b1286e06f32a6086476e1cf2636ee4591be6c515a03f84c5f5bdbf0550ad6440e5614eea29ff878fc7a1a59292ee7076722c6c12bd0561eb01666fc0eaa74acb29400ab1af944693f08c3df1202efb9aafa5204 + 4ebd32cea5c4e8e22ae8d025273d736a7aa4ea99ec35555379d29b64beb35275; + a37fc5cc09f7f62f66b423fcd2dec5de24d264f2c839839c1b06319f + 687dbc68d9f07fd41ccb4f8cde8de201ec2680332bbded4883deea0b58b5 + 4bdd13c17ef292b0ded3caeb5e57fd21df10bc6186265ee6ea45907de6cb822fb2ef953aea358a03e0fce2e1b9511bd332c86e67f123377a8f0256b8dcc73ae1b3c6cd3f104e3cb24284cfed17811d64d492d39ea7496993a25b07 + 2945d83f923e66b0a6689cf0969c003a8fca80e322a4b1bf050c1220450433efb6b6d8a2d820cf27a64b9d47f636845dac557bb3e75f3a18fb8e173416867fcd0ee78ddd9236beec76d55ed58b10f91d07a037791ab96e83c4bf2fb5b205e592c172a5cbc1 + d9971e97c6107f5e95716634e4731360542765a84d798c706f88a6dbbe83b4d0588bbea20e927524f8d21de8ab71a910ed5bae27aaea95bd20fb05563fca2674cd6037d9fce9a1ea0f47fae536d92b837aa391a5a8f6c9b4e5280b66553d7516df90b4bed4 + ed3bb7517af2601dd23e9c5b54c63eeb050f51d15acdaebd6bc47325ffd33ff8; + 9456c95c1bea6079f3867e52 + d663cb3884b2a0a8ff825df752423f3179bfeb89eca385f20ddce5f1f235 + "" + "" + "" + d7bd5a595d894ff087b4120947bda4fdeb956a41b2e9fe9152dd2071e11b0552; + 64672e370ffc37d400a31e8a + ac1d426ce10df73c5ee478b3b63d91024780e974a8a2a0e7a36f84ab1286 + b6 + "" + "" + affeb59e316bcec613e4ba87e80e83c1204f83e9aaba7de2263c76c1778c3c34; + 27e7d01b38a84a6de738721e + d80fd0d7f69fa658abb5a440d304128719b541a9451cead18e4c61d93d1f + "" + 8f + 5a + 92a3d896a62298b49df5d041c3f30f3ca01a387e04bcd3e4e934789fa270f485; + cc53574427767396322b3bf7 + d02cec05093696cec07591ada462271b1d1519eedde0df37a330fe + "" + 8c22ebd77705917b7e32ae88f45a34a8ba3037235e19a394be4d26ce47317d8087684456b4cfc5555e925e3e7b2ebc829b2d0505ea617b0ca9531bcdb96040d39040e632d562643ccb64286303040fcaf679e914eaddc05af8843ce6a427b99a + 984c933c9aa7fd8536cafe98d705ee19c027a3c82e1f655b87325e8694d8982e7da50abdfdda9b9275c6aaf0dd141b8f2c4fe0d4b32d1317efccf6a1768da9d15699af7c8fc90eb6386648e098795b80380933001d47f3484b771cc6435e824a + 300a77fde5151a0a55110605f648e984e5c5e9c297759b420773e0198fd43de6; + 5dc266de31c09165237eeefe + 4b58cc034b9f099f04678c2a9da898b39324cd3087a651014f6796f9c4 + 881d89e127e62221e47e57badd678d490c2f320ff8fb1c42761bd439f3e96dc0ed1d5b2169912af1a4e2c533c52ba3e8c71c23a089e231480aa63c484fb34bd522397f102cb8ecf4f64e329884fe73be257a753b38200bc23f94a079bde2dd98 + d813655dafa15b85419d15c41a5153cce5d0e8c8702db2ba11927589678d4f7b8fcfad4818c411f15f452300903874f9a532ee46496ae753a2340af7b91f9632fc5ae71ae18b40de751ab6b6761ca16434a9935e466e11c1cb072f32a59c313d + ed01665286324cdff1c38648e15ed6c53f9ad08c6d830bbcda44c1a43d662b55b65a02493a13da360250c8f67d83042de2a3cd4b5ef58d6de79ab9b29377377f43b179889b2d73a2a4bda38c8018504a3e3366be90700291e7f9d676bd764661 + 7ad70b7407fb23e1d1cd1aff53cbbd9b27b27f3d5323b2492cb700d6c336a73f; + ba3db646ae909a096697d9a7 + b0556463ff1126ebc43263391424d02739d0787e804d8f1dccf6c897a8a4 + "" + 8431324324041b5302ccd501b538bd03d5cb5c90d1fd3f7d2be187a787032c79ed900764ee4ce1d3fc042c084f7d8c0c48ad7d6f1eabd0fd1ec24a88f26734d5c8d92dbd873a8fe113090d401bea4d28ff49f10ff593adc258e091abd31b62dd1735158f98 + 13c29223881fcb5ac5bcbdfed11fec190f5616ac0b9a48d7c500416887ffeceda025cd1a53cef1b43980cf4930680e43727549984acf076bddb90b889ad22a81bf371bcd9b1bcbcb8e1709cce01ae25f6bf51424b6ca9c6f54cddceff6a536df344e96d66e + 6a5e940b5fd47e1c52ff1d6e898c535bafb686a2b12931f0d5e4a902207c5267; + 765970acc6602da063aae01a + 2a199d3a4f37a5f062d216d2053a83b5d3a0488ab0d2df631b2892cdfcf9 + fdd0f37de9ed67179aeae82fe00009428b297b553230a6d917fa0c1a233c9ebc8a4cba45b20543c540fc1b9dbce078b87a1534acf03897b95a3f372e9f6c5a5f2ae44a7dbce9ba43a39089de20de70d0544b5151db0a16e9769e8f + 2fc12c7f839fab269a0056284a697ffd4113a1cf43b5d5bdce2d86dead83f5a356e9106bedf908db61f1119f9700260ea9379cc7232184d217158fee8ca42e75614739e9007f234fbcd86b0ad8f641a0449b6d9b0f99d1cb4a57a4d6f987feb0ade90aa1d8 + 871ec85dcb564eeb30e76fa18d1c45e6e03a34fa8d3701ae975fe8ef646e5581e70a2d7de65b92d4407925500b00443315317b26a084bb65f2c3c03377dd68c814915a3215d72c409cbbd99261b6ef8d14ddc790a7a7495c7c401ab4d4041607f3f4320eec + 8c4b5793f59a300f6e01ddf60ff510fb1ea408ad470064a3cfe0b1b4931e6535; +} + +rijndael256-ocb3-mct { + 32 e6daf3cc9ccaa1b05a68b6069e290909301ba320423b3a658c9552e67486ac87; + 28 3cab36843515c14a36039eae083324d2ab843e04f30739848bd7bead795a6cd8; + 24 98706671cb1048083d2e2de4692530d8259d4ca91e6f4f995f41bc2bfb575e49; + 20 5f3ad3100cd757cba80500b2cb3159530cebb5b1309b89eff98daa458348119f; + 16 a10c36f02737879b67ae2c4447f6d25cfaaae27916b95e40d2f36a40f9127415; + 12 2b848a4d1f15ffa8a4937abe0bf244488eb69962143c49e942fabdc21bf05bca; + 8 450a06d40fbcfba4feee7f6f176364093dec3f15a4d8aadc83fe1e28909b6ecd; + 4 43de563ee4818834fa190764e0aeda79811ff574b26466ac17415f3289d13715; + 32 42adb7c35588f8c6edb4abfc97b946a1649085165c7b8c3a; + 28 576eaa3954cc439e98263497d95da6b5e3d8279214f574c3; + 24 e28807d93e721c4ee87db0e382b7fd0ef97f7ea132915bb5; + 20 af22f7a7675fad35eb8782c40bd3c732cb1ed35c97654f8a; + 16 fe9d4746e3c184b1515a327e9e928c7a46b5a0cdb283baf9; + 12 9171f1fd2e0453fa5b993e99a6382068b0ca625dd3f9ac39; + 8 16823ab82ac0c840791945b5bce210ad634c57fe5c514cf5; + 4 bed515eaca34486fb2e069335c780d8e7b9b77c602696d9f; + 32 d79599b45b8f8293aaad48235eb95a2f; + 28 91442e4c2c8ae92f9dc870d7c3d6e0b8; + 24 da99ec771ce8684f4ca7ffa5df402ded; + 20 0d20204adc374fa840fa585a2d3a22cd; + 16 c3e2fb19d84accbbc5b715ea29ef175b; + 12 a3643da0859091dbe415fcad234bad6e; + 8 ab4292dc30d15a253e5a5360032cb3ab; + 4 74b7cfd2fc50a48ac5fad7c8d84a27bc; + 32 f53f5dd16d5986d94888a702; + 28 69bcdf722b40237c2e8fcd71; + 24 67e16b822be5718b363b3ff2; + 20 3d6fa2dabad3337e26a72bfc; + 16 389907e4b3cd3d0168d0a819; + 12 ff40fcbbbe7a203fc704dfcd; + 8 c67601e9b9f58b7a464e3f47; + 4 d1b2695277c7c8f8a9e9573c; + 32 238f3b1fc1fc218c; + 28 0f3657da64398b7e; + 24 07ffed4ca9d89a19; + 20 248ef8ba5dd3f022; + 16 b081c4be1451952f; + 12 c6932badc879fb36; + 8 5f41014f77919965; + 4 3d613ca8abe9c4ce; +} diff --git a/symm/t/safer b/symm/t/safer index 67359283..cef5b9d4 100644 --- a/symm/t/safer +++ b/symm/t/safer @@ -377,3 +377,99 @@ safer-pmac1 { 29df3e6057acc87638f508046733d9ff61cdbd 8ca64eea215c495b; } + +safer-ocb3 { + bef260d7bcda163547d348b7551195e7 + 7022907dd1df + "" + "" + "" + c68d1906e4ecf5b7; + f7dac5c9941d26d0c6eb14ad568f86ed + d1dc9268eeee + 53 + "" + "" + 3d2c6b8d272ad1bd; + 3285a6ed810c9b689daaa9060d2d4b60 + 03062365b0a5 + "" + 43 + 1e + ac7b2f4dcf701c36; + 64c76c160f11896c4794846ecfa14a71 + 30c9f1 + "" + 37120634c9519848a877ff77bf79192a5b50ade5d9cd739a + 3d77279a2b3174b4cda74767a200b3ced178c630f4021f95 + 46868129219846b1; + 3d1f337f29549e6b0d27a4ba23408540 + 6a61365120 + 61f7080cc07df0591d8fa21f2dd88374d8cde8e160ad1099 + 7a21635c6d62c9269029df3e6057acc87638f508046733d9 + 73f22628de757cf0ae4533014abe1e212cac8e7dc8d6c704 + b0592f0672c25ce4; + ff61cdbda3b3e9878731ebfedd4705e5 + 05da1435dcea + "" + a7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb6 + 14072ae825472e9f41b4d3608dcb28f76c38dba433fac5ac21885d3590 + 70c90062488d754e; + 21b7f65b000961040ef2f9b2fc5fa450 + 727a9b542cde + 52ebfda19d0ccc520f215eb57bb3a4f3ebbbb1 + 8ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93b + c67a74b2d9ab0e76d4e12ca3f67a21b36b96f6e153876245f24fb860d4 + da1bc80ce1be6ab3; + f4f2aad2605faee2 + b03fb648e27f + "" + "" + "" + 5c58fc2737aa84b2; + ff63102758fe2b69 + ac26afa33498 + 29 + "" + "" + 105063844d7b9bae; + b94586306fed5415 + 4f8f28523c03 + "" + d4 + 0a + bf73c757de4bdf7b; + de1600157846b710 + ee7280 + "" + 7a2219bfb474fd71d891f24bb65d1563259f9eb53b571ea6 + 930c7d41a8b6f15ef14b066dc63cdddb1be6e934551bd1c1 + e40d324516b9b127; + 29c54d57dd2d42f7 + 0800df9fcb + aca48b77dba189196d1ebba10b0467cb9fc2712a199e533f + a9156308cdec3f768281e040a9b9a222bd689aef66f5306c + 1d2eb8f21e5e62392ffee6754fba853ce71e10ac506c9e4d + 57dec2089ee8cd44; + eb0c6b08ac8b0a22 + 260c571b4a42 + "" + bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c037b + 1cd78bee247725a186a54ff71232b3197dbad5c69ea23db3dac003d3f6 + 3d21f3e8ffca5e4d; + a323fe1dc8151784 + 873f0eb5b647 + da6794c18b5337685a96ed65b9aca338527ef1 + 9b09c063c46f88de9fd41e72d7b97e23e6eabdff3bcd211499268878db + 59da4376f65bf4bfdf59cca15597d76b021a759e71d20b382f587e1a74 + ff7e706dfb3aadc7; +} + +safer-ocb3-mct { + 16 fcbfdf66d89efaa3; + 8 7acb5078112677aa; + 16 baa9bc81de93; + 8 ca467bdf7b39; + 16 f6659aeb; + 8 1b3348ec; +} diff --git a/symm/t/safersk b/symm/t/safersk index c58739ee..59926349 100644 --- a/symm/t/safersk +++ b/symm/t/safersk @@ -365,3 +365,99 @@ safersk-pmac1 { 29df3e6057acc87638f508046733d9ff61cdbd 9f8f71cddf2bf6dd; } + +safersk-ocb3 { + bef260d7bcda163547d348b7551195e7 + 7022907dd1df + "" + "" + "" + 6e456312a40d6780; + f7dac5c9941d26d0c6eb14ad568f86ed + d1dc9268eeee + 53 + "" + "" + 65b5cb090a3f28ae; + 3285a6ed810c9b689daaa9060d2d4b60 + 03062365b0a5 + "" + 43 + 63 + 4e6dc1b24486771b; + 64c76c160f11896c4794846ecfa14a71 + 30c9f1 + "" + 37120634c9519848a877ff77bf79192a5b50ade5d9cd739a + fa8d42d4d17056a5cb34c6792272af358e3c7e7b9490aa3f + 3acb963aa0fc701f; + 3d1f337f29549e6b0d27a4ba23408540 + 6a61365120 + 61f7080cc07df0591d8fa21f2dd88374d8cde8e160ad1099 + 7a21635c6d62c9269029df3e6057acc87638f508046733d9 + 8cd70cce2aaf4a9ea62faa31d7146087d2b9b47e7992e17e + 3e16cf32a2faa211; + ff61cdbda3b3e9878731ebfedd4705e5 + 05da1435dcea + "" + a7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb6 + 239d7c4c0f2c17577768de8cbedf192d08e82cfc74a587ab5267ee7e81 + e6f7aad35cceb122; + 21b7f65b000961040ef2f9b2fc5fa450 + 727a9b542cde + 52ebfda19d0ccc520f215eb57bb3a4f3ebbbb1 + 8ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93b + bbd3b140decdd5e0a63b4a38989e770bedbe26054f882cbf1920fbd514 + a71d070227d87267; + f4f2aad2605faee2 + b03fb648e27f + "" + "" + "" + 63e4d0211e0a4daf; + ff63102758fe2b69 + ac26afa33498 + 29 + "" + "" + 0fb3f4a5cc43406a; + b94586306fed5415 + 4f8f28523c03 + "" + d4 + 06 + afaa82d25e44d4db; + de1600157846b710 + ee7280 + "" + 7a2219bfb474fd71d891f24bb65d1563259f9eb53b571ea6 + bc640b0230973b8be088cdc0f0c18fafe95f13d3197d9c09 + e42c5b6c0e33d57e; + 29c54d57dd2d42f7 + 0800df9fcb + aca48b77dba189196d1ebba10b0467cb9fc2712a199e533f + a9156308cdec3f768281e040a9b9a222bd689aef66f5306c + f9f9760a9b9277c4216a7d12c59d78f7cfc3c5fe811f9e38 + 26bd0ba14ccc28d3; + eb0c6b08ac8b0a22 + 260c571b4a42 + "" + bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c037b + 35511a69e4039fa87bf9cccdd152453842004258de53166380645f0c57 + 99979d46633f3381; + a323fe1dc8151784 + 873f0eb5b647 + da6794c18b5337685a96ed65b9aca338527ef1 + 9b09c063c46f88de9fd41e72d7b97e23e6eabdff3bcd211499268878db + b6190f6df6109cb3134a517871e360503ace233210255bd503451ccf78 + b9d9982e2ad6564b; +} + +safersk-ocb3-mct { + 16 3857e95d746bbe01; + 8 545057df78fb5ea9; + 16 c2e0438d09ff; + 8 36b5c340bd6d; + 16 5dee93a9; + 8 8752f8e9; +} diff --git a/symm/t/serpent.local b/symm/t/serpent.local index 42eb27ab..d7a0340f 100644 --- a/symm/t/serpent.local +++ b/symm/t/serpent.local @@ -777,3 +777,216 @@ serpent-pmac1 { 1e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89d4b9b12012e4713df46795630e7952d22bb02d 0c21a0dd3a264c1ef7cfeebd6aa8c2c8; } + +serpent-ocb3 { + 60d7bcda163547d348b7551195 + e77022907dd1dff7dac5c9941d26 + "" + "" + "" + 4f7cf8f6ab514ac1f3727f957c772859; + d0c6eb14ad568f86edd1dc9268 + eeee533285a6ed810c9b689daaa9 + 06 + "" + "" + 49cd7a3bc7a32c2f5ef6c4097d9f3e48; + 0d2d4b6003062365b0a54364c7 + 6c160f11896c4794846ecfa14a71 + "" + 30 + 22 + 1105ad05b7e04476b4c7a746a45538eb; + c9f137120634c9519848a877ff + 77bf79192a5b50ade5d9cd + "" + 739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a + db5d464d5b9a3659805cb7a3e720721f7b6963be1c93ca3d5ad39b5bfb7d12aaedab640a6d098a0561198d05cd9fda2d + 25430830a120e8e713128afa579ce1cc; + 21635c6d62c9269029df3e6057 + acc87638f508046733d9ff61cd + bda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb6 + 21b7f65b000961040ef2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a480 + 402dce04d49efb3aff4154a91ab4117d865b8c1e894e3e0170dbf421ca1a92addbe8599f92ffccaf4a96bf1ea5fe54ee + 00589c1be04b5aff3a9eba045c305801; + 30370c33d090c54215abd6b3ad + 54efc9a38378c5b93bf4f2aad260 + "" + 5faee2b03fb648e27fff63102758fe2b69ac26afa3349829b94586306fed54154f8f28523c03d4de1600157846b710ee72807a2219 + 48023bca0cfcdab03c28493ddbe3146a43b44d5037d87ca0c870c2c0fabb60896dfb1298de927f195884f29edd914e3e2097071103 + 6979cd907d468b65143ea75140e38ebd; + bfb474fd71d891f24bb65d1563 + 259f9eb53b571ea629c54d57dd2d + 42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f768281e040 + a9b9a222bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c + 559ea712ed9f509cf3ac9d44f1ac8cd0c6a11fd7e5250ce0de79f197f51f82903e8da278b4c5dbf8bcbebe7f52446cf523bee00462 + f15cb4b18193f4922298801f9323a3c7; + 037ba323fe1dc8151784873f + 0eb5b647da6794c18b5337685a96 + "" + "" + "" + b7dd404d4f1a01c8ef737b6c2525a3c1; + ed65b9aca338527ef19b09c0 + 63c46f88de9fd41e72d7b97e23e6 + ea + "" + "" + ab6815775c61984db8e9f4927af022a0; + bdff3bcd211499268878dbf3 + 0f1dad89d4b9b12012e4713df467 + "" + 95 + 7b + 70aa0ae770a0161e22bc0ae606c70527; + 630e7952d22bb02d7100b8b6 + 49377d20a8f083455b663e + "" + 4ee1315f3c8f2aebfa921451dcd1af5813b70d30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5e617669c0f + 5ae21390a16833b1553ad00340cf88608eef0c77dec11bf992c8371c330f3c3b76484c95384949ec2cc42d1b943665f4 + e0bd36e53a42d1c06bc4ef6ac241d106; + 16e39815d4e9cfce3ed1ecdf + 3d264a7f16cb16c2e815f422cd + f0c8e30308be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed12ca986981a874498ad0abef8bc4f + cb70e27e98ef1f0446b42fb144d44b6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb + a5b3449e8af9f06e72f5f618131e205714de08712af78c71173e347e29259efd49ef786eebfb7fe5592e2838ca92f9f9 + b6491d77b553f97cc3684ef4e7339515; + 1c8dd0b00951f284649016ed + 00456331854bc78bf43966eb0cfa + "" + 9138ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c04226f + 0eb3df5285a44b93df6263d4a19c3468cc98d13cc57c92671fe450936feedb2d692d6e9b288ca7095ba3a16fc553d2b33f2e5e3285 + ed1441556cce090353a8e651db8b7765; + 30cbb7f0e4a973a8cd190107 + 314717a77456f3ff669c732b58db + 8f48af65f7cc9e3fb90e1721b730374ffc9bc597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003cc0c + ae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f0911e32d65cc1770a18cbfe6effd1ff6778554acf1270485b203a3c1c4c967c0a4 + 72c70c50bfc9891abb5d0f389a48e4ba925f1a5de1b522dfec32d0de805500ef56a0e3b248e52d50461e8673b51591d76aa7aac188 + 22315e09ed36b5e886972e3d97bb191f; + 58cb948bdd409b68 + 7fa3a6827b480aa3a4c84cef64f6 + "" + "" + "" + 30c1077f4bdf19d1a75c2bdb0b791be0; + c9b53bf8f957f4b0 + 3cf43e89957f9a3e8128f8743d16 + 68 + "" + "" + 6f663abf27387105cc24b69ac2377f89; + 7b7bb8deb9bd205b + 70e04c091d205cdad9e9a79b1abf + "" + 91 + 74 + 81956eab259749fa15c9a0c287a3c797; + b0851e5ca605ac84 + 51399587011677508a15dd + "" + e524af3e2bee0646541a42c2ecccb44d65bad397abfaf529ee41cf9a05c7efedef3401539c51d2a90bbf7f1bfc338ab0 + c229d22e2e97fdec03bf8725e466fe3130ef56c17c910ea6f6023fc4f389deb33eea058fd7878ee3f0947107da6ee92d + 5bea96a8d2416fbb9f616e27b8d67b62; + ef5746ea8fdcccd2 + 13e33f7e8a5718fd25014107c8 + e7d715a92add9589d1f5c054b2d983514605ec590294a319b9802068a9f891bc5ba5afabf8c3122d12d7ff3c41122d70 + d17d4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7abc8 + 67125d08b30abdf348054dd642f18f0802d58b7ad3f49abd77ee6e68146696f42a4a73993f0d3fd2754033dfafcf0b49 + 51db397a26bccb5dfb66aa47d15dc1ed; + ad68daac90cfe22d + 2f1f2968cc42fa8b669ed3bb3542 + "" + a9cf44bbc8c6254d980398bd94e66eb4563d405e51881e99027b8ab9aea3ccf860b0009740763d96836c5f87b95460938de1288c69 + e20ad6334c2ecfaf8546c5917542e2b65b534724eefad63e1061805e673a6358d31753bdd4beb457112d41ccb39c306ae4aceb1fea + bb503bc1e42a7c837197827d4c4ba6ac; + d80ea12ff4bb5f06 + 9b8a2e86041c1b9fc214e9ca2186 + ddf1f6a7a3aa7e740da967828e3604b35b15ffaa6c36800d9645563a308ba60076817523bd2abf1261b089 + d8f23a9c2835076a23faac2cdd67771cc667a8331f0a170b66283e4f834a06148f302c3973accd56f6f24e33958b8c2e2352fd61e4 + 13d0dff205001c5b6bf86c8810569bf634631c25dc146faf019d31b13437331abd317718f12e056d365c8d36520746656efd5fa8b1 + a281566357e03991bc302355006a4df0; + fa8fec816ac861a8b33779f09e7a10fc02 + a8f48afa3080ee119a52a9a817e4 + "" + "" + "" + 62e171992b3e9b84abd46d11865c70fd; + f2b94b0820cab383a8cffeea7c48631579 + 9dc875fba578c8ec4837898a9214 + 2b + "" + "" + c00cc0b5bacedb125f578b30d84d2198; + 5b0677da1ac273117b45bcfff5d5f8b6fd + e2893232a9f81d14517ffae475f6 + "" + b9 + 78 + 8a8a1da60db0bbd76cc5c4bcac79da2a; + 4a43a67b3d380d2f9aaafe2dd721c0095c + 8808847689211450ba8095 + "" + ffab1eaadf66fd22ac1976063e113ab61f813e28a1397a7974a1d7f4220c785fe426a5a0e80f678d404147842941feef + 7a160e50b050bb3ca62c12501226cb0551b4dc3349721d71e08ccf2222dd831ac2a108691039f1ba41fc326d2a827bff + da9c04168e6dedb3579c2a9bd76f1692; + fdc2eb44dc8c0d5e8f444f7f4e0c893959 + b74dc23a7bb40e7e0013e51506 + 86d2301b43a15a84e81d7f5cedaa49e2414ebf47970e560475cff206877de69146acc3ab6cf8556b7aa776945948d1b8 + 834df2196c92ec1718dcdeee0d52d9539726d2810391b3f9d10c39b07ae8f08ce7cee4758a386a9943e97dedfbe61e73 + 7e0bd98a04cf07134ff5026bf10c6e2a4fcaead969223f4729ff57cc2d72f9c6976a03e4932fda63cacab98244f36385 + 34b97cb4b3ec851d86540afaefb7e6e5; + 7882cd09c2b9a80f34c0fde11c2481b11f + c76bfa4dbf710a9e544e0c536ca1 + "" + e040f9ad5b04140d98edabe08485290a4d87d13b07398a1458c2c6b61dbdbc1cccada8c1a0a9aabb6c4e3c3554f8fb1ef61614c270 + 58c88119379227a3438f4be71c2b148eaae5dc87f047a10ac315de213b318eb0fd13be48c01b39654ec0521caa1da513b9fc1b9947 + 1176c87b5d31fb87b7454e7aff5104ba; + 295dfc0ca6551ca4bdb75359f91cb9d921 + 056b7de74fc9a9b37154ce6c0b39 + 6179d31f06a1dd5982cbc0d7cb23841da1ae8f4ae480cda98ad6cf2bacf6f9fd3f821330c43f3df6c2b3fa + c7cbcf96523d4723f91801325eb8553236651c96788d73d192ee53b3f3ebd66ddd98cedbe88e245de25b1593b70f8601562d90a9b5 + d5559d4ffc3be85cfdb261126b89cb7e7fae82a3f954bf79ffe6f7603ee58b5d2d37747ecfa24ad41bdaa0b1fd7c82e0e04e81c69f + 507ed27681b30a6cdaab64aba8bb3ac1; +} + +serpent-ocb3-mct { + 16 36d3bf694fedee5e20e35745d9f647e9; + 24 924c5b38d6df87dab11042e56bb0434e; + 32 5b8e3684bde5c8b28bb87796aaf95b17; + 16 506bd45f5b6eb67ceeb408b9; + 24 650f258975a5d1f6596ff2af; + 32 fd5488e927ecafd96722e92b; + 16 5294561007b55710; + 24 d3a5062ec84f5ac8; + 32 2b883de71615444d; +} + +serpent-ocb3-mct { + 32 5b8e3684bde5c8b28bb87796aaf95b17; + 28 1a93fd62a9e9a3cef4407833bcaba842; + 24 924c5b38d6df87dab11042e56bb0434e; + 20 626a7bdd05dfbed8287c7a7cec11b863; + 16 36d3bf694fedee5e20e35745d9f647e9; + 12 5a6486f6ba3b10d486c628147c71a85c; + 10 0664a0cdd817da522ce92837ec06ebc0; + 8 aa155e08b41857c4abe54180e6c50bbb; + 4 328cd59c0a989fb70c0339066da49aa7; + 32 fd5488e927ecafd96722e92b; + 28 f080658ee65dfd9d54e19ae5; + 24 650f258975a5d1f6596ff2af; + 20 d141c903a4d29332b36b2984; + 16 506bd45f5b6eb67ceeb408b9; + 12 3c53bf904f4edbb691e7af8e; + 10 849f7d73dd7e48655f062340; + 8 048b157a38f4281968f840e7; + 4 f52c2156342549de8bf99f08; + 32 2b883de71615444d; + 28 d9776aee81a378ea; + 24 d3a5062ec84f5ac8; + 20 e1e805b319485007; + 16 5294561007b55710; + 12 00edada26968f413; + 10 dff51ca249d51583; + 8 87ec3336240f6f98; + 4 305dce068342b3ca; +} diff --git a/symm/t/skipjack b/symm/t/skipjack index d544da12..2af56e9c 100644 --- a/symm/t/skipjack +++ b/symm/t/skipjack @@ -291,3 +291,54 @@ skipjack-pmac1 { 65b0a54364c76c160f11896c4794846ecfa14a b3a737b39bf1c95d; } + +skipjack-ocb3 { + e4bef260d7bcda163547 + d348b7551195 + "" + "" + "" + 306c2123c229d86a; + e77022907dd1dff7dac5 + c9941d26d0c6 + eb + "" + "" + a0f5e0a9d6193d8e; + 14ad568f86edd1dc9268 + eeee533285a6 + "" + ed + 76 + b1f29902bbde9441; + 810c9b689daaa9060d2d + 4b6003 + "" + 062365b0a54364c76c160f11896c4794846ecfa14a7130c9 + 62299168f2ce7ea1488f71fbde61613002efcc4815d4674b + f9d14a84093df62a; + f137120634c9519848a8 + 77ff77bf79 + 192a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba2340 + 85406a6136512061f7080cc07df0591d8fa21f2dd88374d8 + 7ee7aa9e2d4e7e5f4b9c9e254ffd3868f8ce577bc82b0239 + 0560b1fcaba5682f; + cde8e160ad10997a2163 + 5c6d62c92690 + "" + 29df3e6057acc87638f508046733d9ff61cdbda3b3e9878731ebfedd47 + 914f81636ba12b551c60b41dcf566e447d02d15d2113c09678b1fca4ae + b7161acf1efb88ec; + 05e505da1435dceaa7b1 + cc49ae1d50c3 + 8201a894476b3f102b752eb9529533966f2704 + 3eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde52ebfda19d + 78498440ea075861116531b9ad62fa7d399948260edc0bdd04e04a4327 + 39de18c8572cfd02; +} + +skipjack-ocb3-mct { + 10 63be3f7aef5a5f98; + 10 dbe0b1ff8673; + 10 b26e14c0; +} diff --git a/symm/t/square b/symm/t/square index d9c5fb84..9d0cbf9a 100644 --- a/symm/t/square +++ b/symm/t/square @@ -1061,3 +1061,147 @@ square-pmac1 { b94586306fed54154f8f28523c03d4de1600157846b710ee72807a2219bfb474fd71d891f24bb65d156325 e6d24bd14f25e2fe8909354cdac337f5; } + +square-ocb3 { + f260d7bc + da163547d348b7551195e7702290 + "" + "" + "" + b1669cbf9b59f73b4288eb0761332190; + 7dd1dff7 + dac5c9941d26d0c6eb14ad568f86 + ed + "" + "" + 780716f09513ecb8dd6f322f3901fd27; + d1dc9268 + eeee533285a6ed810c9b689daaa9 + "" + 06 + b8 + 1fcf843450fa4d3da50d8de6525119eb; + 0d2d4b60 + 03062365b0a54364c76c16 + "" + 0f11896c4794846ecfa14a7130c9f137120634c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f29549e6b0d + 33f91dd536f3667b220ac4fa9ef6bec830fc052968f5c3c78141ad56254dbe7fff02e85ea5a278bce0c9a5037caa31f0 + 11621f557ad6c52a82e8d9495bb284e2; + 27a4ba23 + 4085406a6136512061f7080cc0 + 7df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e6057acc87638f508046733d9ff61cdbda3 + b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb621b7 + 1859d78e9ad0fbc8bf76a97f08e6de088994238974dce458f7dc145948b8ba9f8b8f52c82a1ff60046350eeec8936379 + 350f84d218392b1282daa7db5ebc4e5e; + f65b0009 + 61040ef2f9b2fc5fa450727a9b54 + "" + 2cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93bf4f2aa + 664cabfb69a25342a0bcc17049c316c78c412df3efbf75cc192b936dccf87b3c094d51468c20911a477cd6a214c403ff99abec313a + 09b989eae5e6973b675f06ab4b9ad1e7; + d2605fae + e2b03fb648e27fff63102758fe2b + 69ac26afa3349829b94586306fed54154f8f28523c03d4de1600157846b710ee72807a2219bfb474fd71d8 + 91f24bb65d1563259f9eb53b571ea629c54d57dd2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9 + 9f53984003391daa1fe81c1e9385d1d902f330b930b225a8164f06adeaff820d08dfceeba9ae1a9639d556bba8ad6563186d022240 + 64d960c38db07c9ede67bd56b122544e; + 156308cdec3f768281e040a9 + b9a222bd689aef66f5306ceb0c6b + "" + "" + "" + c09ceb18e7c3a8ac514ff85bca3ff3c5; + 08ac8b0a22260c571b4a42bb + 8fdb233bfa6a5cfb0bad7d95214a + de + "" + "" + 80ad7d8b14ff64d06b79cd39c7440775; + 49cb3b6f5fe8368131115c03 + 7ba323fe1dc8151784873f0eb5b6 + "" + 47 + 74 + 6e58478155a6c0007a0323c4235d8e70; + da6794c18b5337685a96ed65 + b9aca338527ef19b09c063 + "" + c46f88de9fd41e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89d4b9b12012e4713df46795630e7952d22bb0 + 867bb322577ed2e766f857c22e0114e95c6ffa900fb90bc3937effe8dfa93140d9a58ba0827e5b06c1304ef17fae2c33 + 0e880f9fe586b0761eb98b29b1636b65; + 2d7100b8b649377d20a8f083 + 455b663e4ee1315f3c8f2aebfa + 921451dcd1af5813b70d30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5e617669c0f16e39815d4e9cfce3e + d1ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd5214 + 738258f0995345cfb20acfae2607aeb91871d5a7b704a82e866350f8e3a28dadef97edc6b7618a12967000642abd3cbe + 6a41eed95fa7c3c529eee84ea0a4770a; + 7ed12ca986981a874498ad0a + bef8bc4fcb70e27e98ef1f0446b4 + "" + 2fb144d44b6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb1c8dd0b00951f284649016ed004563 + fe2c297cdc8e4761c2d70f8ac5c8431bbdc7560712b651f182aa471c5fa6d9569d0f890c8ab2a5dc6e6e61a130a20d533dc013b6e7 + 1722ffbd31d1def40cc073828ccc4cfb; + 31854bc78bf43966eb0cfa91 + 38ddc39908445608fe95e81c2533 + e31c9c1a9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c04226f30cbb7f0e4 + a973a8cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e3fb90e1721b730374ffc9bc597f56ccbb2f294b38766fc69f6 + e55a772b18315f4096513d5bf39f4c42665be5375ccee48d7f7c9bb8ad05644e2a2d92b485a2c42514e2abb4940045ed05b2d15bfa + 01a830efc22048f44dc01e1db446b5bb; + a9f2c0945ffd5050 + 03cc0cae9ce021a5f1fa4ffa9154 + "" + "" + "" + 75029ca958d142837b6cd9138b81c0cf; + 4485f1a1258b2b9b + 8f0911e32d65cc1770a18cbfe6ef + fd + "" + "" + 8568e94583082cdd23e3f72b9f28d106; + 1ff6778554acf127 + 0485b203a3c1c4c967c0a458cb94 + "" + 8b + 4e + 10be6791bce4cff5866df5348e7e9ef3; + dd409b687fa3a682 + 7b480aa3a4c84cef64f6c9 + "" + b53bf8f957f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e + 4511dc2330fa5033e1ac63dd1901ed10c5c919a6eed4e953cef5b7847f86f6db03d68301a6dea2c4f8ff6173da5800a7 + 8bd0072dd3ca8de80eddb1cfca3680fd; + 5ca605ac84513995 + 87011677508a15dde524af3e2b + ee0646541a42c2ecccb44d65bad397abfaf529ee41cf9a05c7efedef3401539c51d2a90bbf7f1bfc338ab0ef5746ea8f + dcccd213e33f7e8a5718fd25014107c8e7d715a92add9589d1f5c054b2d983514605ec590294a319b9802068a9f891bc + 2212a8678c5de88205f0fea2785f6dbe17d974ff4d64a533c573ca6d9a8079a55bd3241f6783705d81498a2426d522d3 + 0e895642d052f0695d3ade0d052738cd; + 5ba5afabf8c3122d + 12d7ff3c41122d70d17d4569eaff + "" + 59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7abc8ad68daac90cfe22d2f1f29 + b5e9c68bbf184cfaece73aa7d566a115709a25c94217851433e62f2a28aa9d45a084f521fc5514af2f66c573ce79d817d74a6480b9 + 613c417ce774d4a717ea6a5fd0ee5b06; + 68cc42fa8b669ed3 + bb3542a9cf44bbc8c6254d980398 + bd94e66eb4563d405e51881e99027b8ab9aea3ccf860b0009740763d96836c5f87b95460938de1288c69d8 + 0ea12ff4bb5f069b8a2e86041c1b9fc214e9ca2186ddf1f6a7a3aa7e740da967828e3604b35b15ffaa6c36800d9645563a308ba600 + 08a8bccee9fb6b7449fdbd1dfcb6836385770d4f6592e27c563250f869ad4262a87159fc9a0d42b61e1f59acfa244c7bdee8cd03ef + f5cf62fa77aba0b2285dc3d231ae2cd5; +} + +square-ocb3-mct { + 16 47b0a29f45c1b000f1a0c27eee7f42e7; + 12 7a80e7d6e556778f77a327928ff4dc35; + 8 886bfcb71cd24995911ed011b231d99e; + 4 d0b2597b73f284932af5a5db0fd1fb3d; + 16 5c3d0dfbee0d8977a7cee660; + 12 6057212ee2684bb36520d44b; + 8 5f0f721b8171461d242bb883; + 4 127b569653ace9af8aac7f47; + 16 4184125b37fbd3fc; + 12 258e75d36b5359b3; + 8 bd8c4a18f64be7cf; + 4 55a5c5e40c4de0e9; +} diff --git a/symm/t/tea b/symm/t/tea index 9d8e5522..e76f9eff 100644 --- a/symm/t/tea +++ b/symm/t/tea @@ -786,3 +786,198 @@ tea-pmac1 { ff63102758fe2b69ac26afa3349829b9458630 df79e3c4601f609a; } + +tea-ocb3 { + 60d7bcda163547d348b7551195 + e77022907dd1 + "" + "" + "" + 50e56f25fe9fa75a; + dff7dac5c9941d26d0c6eb14ad + 568f86edd1dc + 92 + "" + "" + b018725e1da1fc14; + 68eeee533285a6ed810c9b689d + aaa9060d2d4b + "" + 60 + 94 + bce5f4718c762d22; + 03062365b0a54364c76c160f11 + 896c47 + "" + 94846ecfa14a7130c9f137120634c9519848a877ff77bf79 + f63c61926eb91517997efd1a280da07726f45280bd3d5893 + ce2fa9afb1a39afb; + 192a5b50ade5d9cd739a3d1f33 + 7f29549e6b + 0d27a4ba234085406a6136512061f7080cc07df0591d8fa2 + 1f2dd88374d8cde8e160ad10997a21635c6d62c9269029df + 3f60ebe2319bfad8b557bcd414b60e89212bbeea2a5c4373 + 74e2d32d1767921c; + 3e6057acc87638f508046733d9 + ff61cdbda3b3 + "" + e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a89447 + b04de9996b330715ff382cfec0333bfd66421410bf16459d12a0f28f53 + 38b0c98a1f1ec6da; + 6b3f102b752eb9529533966f27 + 043eb621b7f6 + 5b000961040ef2f9b2fc5fa450727a9b542cde + 52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c + f7e226026675e1adc5cf37952abccc77b8154368557b87ec40477620f8 + 44b45cf50973cb50; + 33d090c54215ab + d6b3ad54efc9 + "" + "" + "" + 1eb02bffdd9d7dc6; + a38378c5b93bf4 + f2aad2605fae + e2 + "" + "" + 58ee8252984db2d4; + b03fb648e27fff + 63102758fe2b + "" + 69 + d4 + 961e871fd84b5a74; + ac26afa3349829 + b94586 + "" + 306fed54154f8f28523c03d4de1600157846b710ee72807a + 0e6295372bd9df61b2ca8d2a383154e2c70fd3ca68805de6 + b8a6cce0dd7f6222; + 2219bfb474fd71 + d891f24bb6 + 5d1563259f9eb53b571ea629c54d57dd2d42f70800df9fcb + aca48b77dba189196d1ebba10b0467cb9fc2712a199e533f + fd0562d5b003e68f0d1d72c4e082b87827f85ee88b52cd87 + 1e835d35eb0cd334; + a9156308cdec3f + 768281e040a9 + "" + b9a222bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb23 + 41c1cd96958e4f6ffaa16db2ec8a521140e548564fccdfb890ab8939f0 + 56271f56c7ea11ed; + 3bfa6a5cfb0bad + 7d95214ade49 + cb3b6f5fe8368131115c037ba323fe1dc81517 + 84873f0eb5b647da6794c18b5337685a96ed65b9aca338527ef19b09c0 + fc1d24d91e4ab2c51590e2a94796bf4da4a50a6c07e20a40fb1981d17a + c8e3e3fd09cfb494; + 63c46f88de9fd41e72d7 + b97e23e6eabd + "" + "" + "" + b222e91b3dfc4b68; + ff3bcd211499268878db + f30f1dad89d4 + b9 + "" + "" + ceaecf08444b8cd3; + b12012e4713df4679563 + 0e7952d22bb0 + "" + 2d + a2 + d537e5734f7de7da; + 7100b8b649377d20a8f0 + 83455b + "" + 663e4ee1315f3c8f2aebfa921451dcd1af5813b70d30ce2f + 4020ccd7a166229e19cd4c48b61701120098e7dad7780102 + ef64295063a916fa; + 1fef6ef315d079839180 + 5da08da3ae + fc5f8584b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d + 264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0 + 07c0c12b3fad029d165bb6b6a9363c7699a27081a8aaf72b + f984336df824fe7e; + b7cadcb658b970e47479 + a684b5aefa69 + "" + a4cd52147ed12ca986981a874498ad0abef8bc4fcb70e27e98ef1f0446 + c19e2396ffc0dd7c73a0f53b39e90139179cefc32e75f8d50f5f627a39 + 2a57fec6502d09d9; + b42fb144d44b6d00f06d + c188d472a784 + e0c6f21195a3b9f4ae985511265febd11c1647 + 20eef9eb1c8dd0b00951f284649016ed00456331854bc78bf43966eb0c + 3fb5c778395cfbfbd94d6707cb18520f9b95b101e5f1673248f37afb8f + 01ba4da3facd1ec8; + fa9138ddc399084456 + 08fe95e81c25 + "" + "" + "" + ef931af545c454ab; + 33e31c9c1a9851bc28 + 10d858cbbc84 + 24 + "" + "" + c24d1e102b084b5e; + d126b807e6daa089c3 + f9099c5ffb82 + "" + 41 + e8 + 3b28cf6d12081293; + 73d7634c04226f30cb + b7f0e4 + "" + a973a8cd190107314717a77456f3ff669c732b58db8f48af + 27a3f2e9c0dbf9ee78fe2eaea691734d96105ec04619032b + 552e65ed80338e08; + 65f7cc9e3fb90e1721 + b730374ffc + 9bc597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003 + cc0cae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f0911 + 45aa335db92540c2bcd0ec28dd97d101c4e14776c4fd1d04 + fa2cf5a4f20122ef; + e32d65cc1770a18cbf + e6effd1ff677 + "" + 8554acf1270485b203a3c1c4c967c0a458cb948bdd409b687fa3a6827b + 44c70463fafaed7e9b3de27cf5c92511a88eeaf9453b1da16914f9c61c + 62e9efc911c2b6d8; + 480aa3a4c84cef64f6 + c9b53bf8f957 + f4b03cf43e89957f9a3e8128f8743d16687b7b + b8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605ac84 + d848b6c4ea2e04b8599c41fa786fbac28cbef5ab4039415ca71d4678c7 + 19c2d53e7566afc7; +} + +tea-ocb3-mct { + 16 cb326883e2a7abc7; + 14 129631272316ca86; + 12 c0a6fdaab85e1578; + 10 112f7058a53b3c59; + 8 786b90684bfe1e77; + 6 842c674eb1cff4ed; + 4 f1319ace9cb4027c; + 16 fd0cc4fec30a; + 14 215b15aeab0e; + 12 f23528992843; + 10 48cacf15625e; + 8 74b0608cc983; + 6 d0dd11b11aa8; + 4 1960a6aa86d6; + 16 b9865f9f; + 14 6f09a6bc; + 12 b32b1dc6; + 10 13e1a721; + 8 b5aefa26; + 6 c2c46207; + 4 b0bf9065; +} diff --git a/symm/t/twofish.local b/symm/t/twofish.local index f840c2e0..1ec96057 100644 --- a/symm/t/twofish.local +++ b/symm/t/twofish.local @@ -713,3 +713,204 @@ twofish-pmac1 { 1e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89d4b9b12012e4713df46795630e7952d22bb02d e8dc0b7392f193529199018bd6939012; } + +twofish-ocb3 { + 60d7bcda163547d348b7551195 + e77022907dd1dff7dac5c9941d26 + "" + "" + "" + 7f2677b3ee050809f5e4a511a007024d; + d0c6eb14ad568f86edd1dc9268 + eeee533285a6ed810c9b689daaa9 + 06 + "" + "" + be8deddf16817c9c36d0fd7a1bfbee5e; + 0d2d4b6003062365b0a54364c7 + 6c160f11896c4794846ecfa14a71 + "" + 30 + c0 + 08ab7139235abe4995e765e6a3cb82a8; + c9f137120634c9519848a877ff + 77bf79192a5b50ade5d9cd + "" + 739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a + 47e1cc7b95ebd79869a91c2f062b8f2f577d56908f819cd78f55430e51223e2a5e37bac236601388a2b434c26aa8e7d2 + 5507241b459462d018dae1537cb30e8f; + 21635c6d62c9269029df3e6057 + acc87638f508046733d9ff61cd + bda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb6 + 21b7f65b000961040ef2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a480 + 7f7357f93fcbabb0d2900992381ab4c3ace2bb992327a4d3d62ff63756b7ef734a0c2a6de3c4b01f76c3531ddd58edcf + 947dd27aa266be2c3d043571d4a14bb8; + 30370c33d090c54215abd6b3ad + 54efc9a38378c5b93bf4f2aad260 + "" + 5faee2b03fb648e27fff63102758fe2b69ac26afa3349829b94586306fed54154f8f28523c03d4de1600157846b710ee72807a2219 + baaa3ba12dcb88379960d13a294e16ae35fc238cca7e1ebd514ef33d2581ffff81c2860478a0ac7be7e2aec8b16ea37fe9e7df6f40 + b106b18872d92b55b10125092c07ca8a; + bfb474fd71d891f24bb65d1563 + 259f9eb53b571ea629c54d57dd2d + 42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f768281e040 + a9b9a222bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c + 3c67bd32c69ef6446bcf3b1ede303d6bc287368abaa84bbb26ead3899423d3099eca75c966044b67bafb88404ad639fae5857f3a6d + fc24dd4b1e6fdad71a59b7595a9e776e; + 037ba323fe1dc8151784873f + 0eb5b647da6794c18b5337685a96 + "" + "" + "" + 8b63ff209b6e7a0391301e76a4e0ea39; + ed65b9aca338527ef19b09c0 + 63c46f88de9fd41e72d7b97e23e6 + ea + "" + "" + a433659f0885976882831a3eb89eed53; + bdff3bcd211499268878dbf3 + 0f1dad89d4b9b12012e4713df467 + "" + 95 + 6d + 42fe65d65b86c7528a73f89a0ccdf4de; + 630e7952d22bb02d7100b8b6 + 49377d20a8f083455b663e + "" + 4ee1315f3c8f2aebfa921451dcd1af5813b70d30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5e617669c0f + 674e1ecd1a10232c74655502be244c4fb08e1f727cb9131f2d2e46de210815b286fc3a75d4e3e1d50c82aa1453b3ca08 + fa220b12d50ce64f83a4884807d53c83; + 16e39815d4e9cfce3ed1ecdf + 3d264a7f16cb16c2e815f422cd + f0c8e30308be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed12ca986981a874498ad0abef8bc4f + cb70e27e98ef1f0446b42fb144d44b6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb + 8b26c53a06f4ce39b4f35da14098aa964a66b58d9d3385ac71fc9a4f31a6d2c69bd41780ef50785b2d4dc3c8d8de5ec3 + cb0b3d4ebe62634b66cb4c2f07a22bb8; + 1c8dd0b00951f284649016ed + 00456331854bc78bf43966eb0cfa + "" + 9138ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c04226f + 45a59590b5218d7503eac38def06f24dde786aee5d74aa5818501d881b5955b3404fc92c02e671c95f03b6e10c875e43309e6314d8 + cc019326324d5f7a3ccfbf7fb4b4d007; + 30cbb7f0e4a973a8cd190107 + 314717a77456f3ff669c732b58db + 8f48af65f7cc9e3fb90e1721b730374ffc9bc597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003cc0c + ae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f0911e32d65cc1770a18cbfe6effd1ff6778554acf1270485b203a3c1c4c967c0a4 + 601106b9872e22a419d22e77179a9d3f2f49259f77629473d6fe8cca0c7f80e94230ebb6c59aeaf544a26537b633cf3faca9afaba8 + 3eb85702ecc6a6208ff54e70c555d560; + 58cb948bdd409b68 + 7fa3a6827b480aa3a4c84cef64f6 + "" + "" + "" + 536ee06e4186eb19069cc7d2611bf1da; + c9b53bf8f957f4b0 + 3cf43e89957f9a3e8128f8743d16 + 68 + "" + "" + 7eb7549c58f0b3e0e900694ad60a34f2; + 7b7bb8deb9bd205b + 70e04c091d205cdad9e9a79b1abf + "" + 91 + a3 + c223c24ae40f10208b2d07032bf63b9c; + b0851e5ca605ac84 + 51399587011677508a15dd + "" + e524af3e2bee0646541a42c2ecccb44d65bad397abfaf529ee41cf9a05c7efedef3401539c51d2a90bbf7f1bfc338ab0 + 54484aa14a10c80f224295d4fdc98a962cb1a75c388282477149c9e2ad42cb7e19f72d20ecc895ffcdd94e5e184d4195 + 7790694ff014f4f29d8875d3483c665d; + ef5746ea8fdcccd2 + 13e33f7e8a5718fd25014107c8 + e7d715a92add9589d1f5c054b2d983514605ec590294a319b9802068a9f891bc5ba5afabf8c3122d12d7ff3c41122d70 + d17d4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7abc8 + 873b418fb6d2d8038dd78169b110a57f6e6c58d917f938d27bf4cdb6a9a3e64b6782c71fa8001c22b4025ca054cdc7d4 + 80b7822cbc9921b5249460298edc38b0; + ad68daac90cfe22d + 2f1f2968cc42fa8b669ed3bb3542 + "" + a9cf44bbc8c6254d980398bd94e66eb4563d405e51881e99027b8ab9aea3ccf860b0009740763d96836c5f87b95460938de1288c69 + 0be9726d678b4975083f0553c995e8fe2e9397ae7b1099320daeff9b57e43d306f05d8806cda76754bde21c5aa5a038b2ecd64eff2 + 5fb04d39cbaf88ea62135df4d4661bf0; + d80ea12ff4bb5f06 + 9b8a2e86041c1b9fc214e9ca2186 + ddf1f6a7a3aa7e740da967828e3604b35b15ffaa6c36800d9645563a308ba60076817523bd2abf1261b089 + d8f23a9c2835076a23faac2cdd67771cc667a8331f0a170b66283e4f834a06148f302c3973accd56f6f24e33958b8c2e2352fd61e4 + dfbe4cf0fe2983dc101e9daf7d40770c0e6f679e56fe4947602c739ebf22782fb98932e02eb14973d825ea72fb651b6eafca5232ba + f92fdadf740caf2c4ea9666b7b052af2; + fa8fec816ac861a8b33779f09e7a10fc02 + a8f48afa3080ee119a52a9a817e4 + "" + "" + "" + 94c3b0151d59ed8a75ce295b97ca07f1; + f2b94b0820cab383a8cffeea7c48631579 + 9dc875fba578c8ec4837898a9214 + 2b + "" + "" + c88555532a51ef0d2999fd4b5964866b; + 5b0677da1ac273117b45bcfff5d5f8b6fd + e2893232a9f81d14517ffae475f6 + "" + b9 + bb + 2b2e9ebf26398af33b06cae0b1edf872; + 4a43a67b3d380d2f9aaafe2dd721c0095c + 8808847689211450ba8095 + "" + ffab1eaadf66fd22ac1976063e113ab61f813e28a1397a7974a1d7f4220c785fe426a5a0e80f678d404147842941feef + aa8ff926ae1d31b79b276ba4c6365896a9ac3f2b901cc6edbd98ef230dcb0c1175fc4cda3d3bab4b0cd0761ec60d1bf9 + 679ea4952bdb67410905826ee2164b91; + fdc2eb44dc8c0d5e8f444f7f4e0c893959 + b74dc23a7bb40e7e0013e51506 + 86d2301b43a15a84e81d7f5cedaa49e2414ebf47970e560475cff206877de69146acc3ab6cf8556b7aa776945948d1b8 + 834df2196c92ec1718dcdeee0d52d9539726d2810391b3f9d10c39b07ae8f08ce7cee4758a386a9943e97dedfbe61e73 + 5e3f9325ceafcf8ab3c05194722e13093f75502a722f012fcf67c3f78d905711e90f6f8b2cf11e4911fcf8a988c95fd9 + 715a5d5c308eb6c2d35c87de8c9bc36d; + 7882cd09c2b9a80f34c0fde11c2481b11f + c76bfa4dbf710a9e544e0c536ca1 + "" + e040f9ad5b04140d98edabe08485290a4d87d13b07398a1458c2c6b61dbdbc1cccada8c1a0a9aabb6c4e3c3554f8fb1ef61614c270 + f0849293c90d1b433a612900ab035a2359b4b0f40dae24c375d721449707bd4fbec89c934fc1610231b4171407dddf5d1cd26e4588 + e8b6889f97e92f7f90bd3367a6509d3c; + 295dfc0ca6551ca4bdb75359f91cb9d921 + 056b7de74fc9a9b37154ce6c0b39 + 6179d31f06a1dd5982cbc0d7cb23841da1ae8f4ae480cda98ad6cf2bacf6f9fd3f821330c43f3df6c2b3fa + c7cbcf96523d4723f91801325eb8553236651c96788d73d192ee53b3f3ebd66ddd98cedbe88e245de25b1593b70f8601562d90a9b5 + b1f9684caf6b151fdfcf38fcc9280ba779c2c5845bf3f3778eec5d7157134dd51c762d40ede77e70255f24e7cde7fb41c4e87aef3e + ae37ce3b049000e9a941f2e36ffc1b98; +} + +twofish-ocb3-mct { + 32 e9ce6449d92a77813175926010259b8e; + 28 a99db77f8c91ea244b94208509e02f0c; + 24 9a9b6ce8abdbf68c23f2ad13d9e46119; + 20 c8ef353c81e5742726a0128dd0a0f588; + 16 9c839aab8a36976e9d320767766e0aa6; + 12 7f3551b1eb590266c7d59ec6b2b14aa8; + 10 15fd08dea6427de5fb88050905d313b5; + 8 3615f256e0edc05af17b680d13534820; + 4 5a7c50c4e1263d509f2a263ed3587b2d; + 32 fbe280898f5232dfb0abd143; + 28 0816b9db96448972f47cc0b0; + 24 1fdbf8b9482aa91ef2975556; + 20 3292677aa668b89b179fc183; + 16 f1f605105a477669efdd0426; + 12 aa1d9537f7ae2c5c1729c147; + 10 e9b833d9ff3c9fc07b037282; + 8 138e0305a1520249dd678e0d; + 4 ebe50e379a1973275bca0d3d; + 32 0a09c938c2fa5dba; + 28 3e38764a044b24fb; + 24 fe6aa4380d1b161e; + 20 0e065914f197a226; + 16 31747d608f91f1a7; + 12 ffc71de4b3eec92d; + 10 fbe711df96a56989; + 8 b38b5c7577aea195; + 4 9530ea1063f27742; +} diff --git a/symm/t/xtea b/symm/t/xtea index 76ac4ac2..0cea08b6 100644 --- a/symm/t/xtea +++ b/symm/t/xtea @@ -782,3 +782,198 @@ xtea-pmac1 { ff63102758fe2b69ac26afa3349829b9458630 5017699c228b645c; } + +xtea-ocb3 { + 60d7bcda163547d348b7551195 + e77022907dd1 + "" + "" + "" + 5d2c01e9160963e2; + dff7dac5c9941d26d0c6eb14ad + 568f86edd1dc + 92 + "" + "" + f4290b5fa1095a3b; + 68eeee533285a6ed810c9b689d + aaa9060d2d4b + "" + 60 + 86 + a0258d79cfe3419c; + 03062365b0a54364c76c160f11 + 896c47 + "" + 94846ecfa14a7130c9f137120634c9519848a877ff77bf79 + 6610c7e7e150973b3af3229eaca70189ec0e13b564297b84 + 235c7f65cfd0cda9; + 192a5b50ade5d9cd739a3d1f33 + 7f29549e6b + 0d27a4ba234085406a6136512061f7080cc07df0591d8fa2 + 1f2dd88374d8cde8e160ad10997a21635c6d62c9269029df + ea5f7d5a908f059911b6b766f706d5f3c9a1b7d5b4d42065 + ba47585a0fa5b8d2; + 3e6057acc87638f508046733d9 + ff61cdbda3b3 + "" + e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a89447 + 1eb152c297208c394377db7669f0147c95b8fac5b1b8607d9584253b23 + d9340baabda4544b; + 6b3f102b752eb9529533966f27 + 043eb621b7f6 + 5b000961040ef2f9b2fc5fa450727a9b542cde + 52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c + 67480201e5ad84d5c418b97dd662d14467346d3a41358000bcd2f70ad4 + c401dcec1ed2f580; + 33d090c54215ab + d6b3ad54efc9 + "" + "" + "" + 55b5295ceea5a2b0; + a38378c5b93bf4 + f2aad2605fae + e2 + "" + "" + 0f315886523d1ef8; + b03fb648e27fff + 63102758fe2b + "" + 69 + f9 + 6363d821109640b7; + ac26afa3349829 + b94586 + "" + 306fed54154f8f28523c03d4de1600157846b710ee72807a + 5d059d165b480d0bd30aa01fbc99b6c73bb78a97846f94e0 + dd5e7c83be0625ef; + 2219bfb474fd71 + d891f24bb6 + 5d1563259f9eb53b571ea629c54d57dd2d42f70800df9fcb + aca48b77dba189196d1ebba10b0467cb9fc2712a199e533f + 02ba51adcc2bb6ba3ab41756291366f14f0cb20893fa39a9 + 2b280bddba65b2fa; + a9156308cdec3f + 768281e040a9 + "" + b9a222bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb23 + cb82582817fa2dd3563bbc12c501093140d5df1fdbd0a319ad4f28cb28 + 0da5ea5b1a5fdddd; + 3bfa6a5cfb0bad + 7d95214ade49 + cb3b6f5fe8368131115c037ba323fe1dc81517 + 84873f0eb5b647da6794c18b5337685a96ed65b9aca338527ef19b09c0 + 2da5aa1294ef89aacc993ebd46ebec94a3feac279d392c27d92b0dbd30 + f2713c40cf993ef3; + 63c46f88de9fd41e72d7 + b97e23e6eabd + "" + "" + "" + f3501e0fcf27dbb5; + ff3bcd211499268878db + f30f1dad89d4 + b9 + "" + "" + 87b3dbbf4f9cc61d; + b12012e4713df4679563 + 0e7952d22bb0 + "" + 2d + c0 + 5618eb373dd8374f; + 7100b8b649377d20a8f0 + 83455b + "" + 663e4ee1315f3c8f2aebfa921451dcd1af5813b70d30ce2f + 99096150a0fe314a00a2336f097ad0f885f03c0b7cccd127 + a66de7481d491c0c; + 1fef6ef315d079839180 + 5da08da3ae + fc5f8584b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d + 264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0 + 3a678d2a777b2eaa8d344e42aedd5e722ffef69ba742ae1a + d6bc78818c3bb4a3; + b7cadcb658b970e47479 + a684b5aefa69 + "" + a4cd52147ed12ca986981a874498ad0abef8bc4fcb70e27e98ef1f0446 + 85540182992781ca0104d764814e47ede859164af3405567d0c98bc7a0 + 8857121b533f8a6b; + b42fb144d44b6d00f06d + c188d472a784 + e0c6f21195a3b9f4ae985511265febd11c1647 + 20eef9eb1c8dd0b00951f284649016ed00456331854bc78bf43966eb0c + 8e650a51a481be8fa4eb4277832e68fef19321017bfcb05543ccbd1278 + b58014483ea856ce; + fa9138ddc399084456 + 08fe95e81c25 + "" + "" + "" + d6f325e74486f817; + 33e31c9c1a9851bc28 + 10d858cbbc84 + 24 + "" + "" + 1b88f76f4bff9de0; + d126b807e6daa089c3 + f9099c5ffb82 + "" + 41 + 8e + 1f85ea188d2fbe58; + 73d7634c04226f30cb + b7f0e4 + "" + a973a8cd190107314717a77456f3ff669c732b58db8f48af + 8ac6753b0a1edc91a058b5bd8cd84f6e2d84a066d3263392 + ea000b35774b2c35; + 65f7cc9e3fb90e1721 + b730374ffc + 9bc597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003 + cc0cae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f0911 + 96bdfd04ff0191407c3b1d881eb29c718dbfc93ef7852b24 + 3b4e8b97f9c055ea; + e32d65cc1770a18cbf + e6effd1ff677 + "" + 8554acf1270485b203a3c1c4c967c0a458cb948bdd409b687fa3a6827b + 99ab24f8a320e106aa12864be588d6af0459d33e27a7b0ab9dcad9de9d + f740e2e18cae5773; + 480aa3a4c84cef64f6 + c9b53bf8f957 + f4b03cf43e89957f9a3e8128f8743d16687b7b + b8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605ac84 + 8d22fd98971cd873b0fab7bd557d5c4076eca3ed5f5acf7fa656bcc0b2 + 16899233ed9068ed; +} + +xtea-ocb3-mct { + 16 8cf53d7d6b43cdf1; + 14 5583f3a52de141d8; + 12 0b6565df07a02f3c; + 10 39da0a29f89a2699; + 8 24ea4af6cf4b09f8; + 6 6b4a51ac943cfa79; + 4 1f1b844caf0ddbae; + 16 6c4482111229; + 14 117519ba3a0f; + 12 ceb3bd9e235c; + 10 4d6a4907b3b5; + 8 6f7224393f2c; + 6 4629c2df66b4; + 4 c0ce4bd2a198; + 16 9ce1b811; + 14 b50aeacb; + 12 7c8e696b; + 10 8a6a0f17; + 8 f0422ae8; + 6 1c8cb415; + 4 b31dc24a; +} diff --git a/utils/advmodes b/utils/advmodes index c65a9338..bee4e347 100755 --- a/utils/advmodes +++ b/utils/advmodes @@ -1,6 +1,6 @@ #! /usr/bin/python -from sys import argv +from sys import argv, exit from struct import unpack, pack from itertools import izip import catacomb as C @@ -587,6 +587,43 @@ def pmac2(E, m): else: a ^= pad10star(tl, blksz) ^ mul_blk_gf(o, 5, p) return E.encrypt(a) +def ocb3_masks(E): + Lgamma, _ = ocb_masks(E) + Lstar = Lgamma[0] + Ldollar = Lgamma[1] + return Lstar, Ldollar, Lgamma[2:] + +def dump_ocb3(E): + Lstar, Ldollar, Lgamma = ocb3_masks(E) + print 'L_* = %s' % hex(Lstar) + print 'L_$ = %s' % hex(Ldollar) + for i, lg in enumerate(Lgamma[:16]): + print 'L x^%d = %s' % (i, hex(lg)) + +def pmac3(E, m): + ## Note that `PMAC3' is /not/ a secure MAC. It depends on other parts of + ## OCB3 to prevent a rather easy linear-algebra attack. + blksz = E.__class__.blksz + Lstar, Ldollar, Lgamma = ocb3_masks(E) + a = o = Z(blksz) + i = 0 + v, tl = blocks0(m, blksz) + for x in v: + i += 1 + b = ntz(i) + o ^= Lgamma[b] + a ^= E.encrypt(x ^ o) + if VERBOSE: + print 'Z[%d]: %d -> %s' % (i, b, hex(o)) + print 'A[%d]: %s' % (i, hex(a)) + if tl: + o ^= Lstar + a ^= E.encrypt(pad10star(tl, blksz) ^ o) + if VERBOSE: + print 'Z[%d]: * -> %s' % (i, hex(o)) + print 'A[%d]: %s' % (i, hex(a)) + return a + def pmac1_pub(E, m): if VERBOSE: dump_ocb(E) return pmac1(E, m), @@ -734,6 +771,138 @@ def ocb2dec(E, n, h, y, t): if t == u[:len(t)]: return C.ByteString(m), else: return None, +OCB3_STRETCH = { 4: ( 4, 17), + 8: ( 5, 25), + 12: ( 6, 33), + 16: ( 6, 8), + 24: ( 7, 40), + 32: ( 8, 1), + 48: ( 8, 80), + 64: ( 8, 176), + 96: ( 9, 160), + 128: ( 9, 352), + 200: (10, 192) } + +def ocb3nonce(E, n, tsz): + + ## Figure out how much we need to glue onto the nonce. This ends up being + ## [t mod w]_v || 0^p || 1 || N, where w is the block size in bits, t is + ## the tag length in bits, v = floor(log_2(w - 1)) + 1, and p = w - l(N) - + ## v - 1. But this is an annoying way to think about it because of the + ## byte misalignment. Instead, think of it as a byte-aligned prefix + ## encoding the tag and an `is the nonce full-length' flag, followed by + ## optional padding, and then the nonce: + ## + ## F || N if l(N) = w - f + ## F || 0^p || 1 || N otherwise + ## + ## where F is [t mod w]_v || 0^{f-v-1} || b; f = floor(log_2(w - 1)) + 2; + ## b is 1 if l(N) = w - f, or 0 otherwise; and p = w - f - l(N) - 1. + blksz = E.__class__.blksz + tszbits = min(C.MP(8*blksz - 1).nbits, 8) + fwd = tszbits/8 + 1 + f = 8*(tsz%blksz) << + 8*fwd - tszbits + + ## Form the augmented nonce. + nb = C.WriteBuffer() + nsz, nwd = len(n), blksz - fwd + if nsz == nwd: f |= 1 + nb.put(C.MP(f).storeb(fwd)) + if nsz < nwd: nb.zero(nwd - nsz - 1).putu8(1) + nb.put(n) + nn = C.ByteString(nb) + if VERBOSE: print 'aug-nonce = %s' % hex(nn) + + ## Calculate the initial offset. + split, shift = OCB3_STRETCH[blksz] + t2pw = C.MP(0).setbit(8*blksz) - 1 + lomask = (C.MP(0).setbit(split) - 1) + himask = ~lomask + top, bottom = nn&himask.storeb2c(blksz), C.MP.loadb(nn)&lomask + ktop = C.MP.loadb(E.encrypt(top)) + stretch = (ktop << 8*blksz) | (ktop ^ (ktop << shift)&t2pw) + o = (stretch >> 8*blksz - bottom).storeb(blksz) + if VERBOSE: + print 'stretch = %s' % hex(stretch.storeb(2*blksz)) + print 'Z[0] = %s' % hex(o) + + return o + +def ocb3enc(E, n, h, m, tsz = None): + blksz = E.__class__.blksz + if tsz is None: tsz = blksz + Lstar, Ldollar, Lgamma = ocb3_masks(E) + if VERBOSE: dump_ocb3(E) + + ## Set things up. + o = ocb3nonce(E, n, tsz) + a = C.ByteString.zero(blksz) + + ## Split the message into blocks. + i = 0 + y = C.WriteBuffer() + v, tl = blocks0(m, blksz) + for x in v: + i += 1 + b = ntz(i) + o ^= Lgamma[b] + a ^= x + if VERBOSE: + print 'Z[%d]: %d -> %s' % (i, b, hex(o)) + print 'A[%d]: %s' % (i, hex(a)) + y.put(E.encrypt(x ^ o) ^ o) + if tl: + o ^= Lstar + n = len(tl) + pad = E.encrypt(o) + a ^= pad10star(tl, blksz) + if VERBOSE: + print 'Z[%d]: * -> %s' % (i, hex(o)) + print 'A[%d]: %s' % (i, hex(a)) + y.put(tl ^ pad[0:n]) + o ^= Ldollar + t = E.encrypt(a ^ o) ^ pmac3(E, h) + return C.ByteString(y), C.ByteString(t[:tsz]) + +def ocb3dec(E, n, h, y, t): + blksz = E.__class__.blksz + tsz = len(t) + Lstar, Ldollar, Lgamma = ocb3_masks(E) + if VERBOSE: dump_ocb3(E) + + ## Set things up. + o = ocb3nonce(E, n, tsz) + a = C.ByteString.zero(blksz) + + ## Split the message into blocks. + i = 0 + m = C.WriteBuffer() + v, tl = blocks0(y, blksz) + for x in v: + i += 1 + b = ntz(i) + o ^= Lgamma[b] + if VERBOSE: + print 'Z[%d]: %d -> %s' % (i, b, hex(o)) + print 'A[%d]: %s' % (i, hex(a)) + u = E.encrypt(x ^ o) ^ o + m.put(u) + a ^= u + if tl: + o ^= Lstar + n = len(tl) + pad = E.encrypt(o) + if VERBOSE: + print 'Z[%d]: * -> %s' % (i, hex(o)) + print 'A[%d]: %s' % (i, hex(a)) + u = tl ^ pad[0:n] + m.put(u) + a ^= pad10star(u, blksz) + o ^= Ldollar + u = E.encrypt(a ^ o) ^ pmac3(E, h) + if t == u[:tsz]: return C.ByteString(m), + else: return None, + def ocbgen(bc): w = bc.blksz return [(w, 0, 0), (w, 1, 0), (w, 0, 1), @@ -742,6 +911,44 @@ def ocbgen(bc): (w, 0, 3*w + 5), (w, 3*w - 5, 3*w + 5)] +def ocb3gen(bc): + w = bc.blksz + return [(w - 2, 0, 0), (w - 2, 1, 0), (w - 2, 0, 1), + (w - 5, 0, 3*w), + (w - 3, 3*w, 3*w), + (w - 2, 0, 3*w + 5), + (w - 2, 3*w - 5, 3*w + 5)] + +def ocb3_mct(bc, ksz, tsz): + k = C.ByteString(C.WriteBuffer().zero(ksz - 4).putu32(8*tsz)) + E = bc(k) + n = C.MP(1) + nw = bc.blksz - 4 + cbuf = C.WriteBuffer() + for i in xrange(128): + s = C.ByteString.zero(i) + y, t = ocb3enc(E, n.storeb(nw), s, s, tsz); n += 1; cbuf.put(y).put(t) + y, t = ocb3enc(E, n.storeb(nw), EMPTY, s, tsz); n += 1; cbuf.put(y).put(t) + y, t = ocb3enc(E, n.storeb(nw), s, EMPTY, tsz); n += 1; cbuf.put(y).put(t) + _, t = ocb3enc(E, n.storeb(nw), C.ByteString(cbuf), EMPTY, tsz) + print hex(t) + +def ocb3_mct2(bc): + k = C.bytes('000102030405060708090a0b0c0d0e0f') + E = bc(k) + tsz = min(E.blksz, 32) + n = C.MP(1) + cbuf = C.WriteBuffer() + for i in xrange(128): + sbuf = C.WriteBuffer() + for j in xrange(i): sbuf.putu8(j) + s = C.ByteString(sbuf) + y, t = ocb3enc(E, n.storeb(2), s, s, tsz); n += 1; cbuf.put(y).put(t) + y, t = ocb3enc(E, n.storeb(2), EMPTY, s, tsz); n += 1; cbuf.put(y).put(t) + y, t = ocb3enc(E, n.storeb(2), s, EMPTY, tsz); n += 1; cbuf.put(y).put(t) + _, t = ocb3enc(E, n.storeb(2), C.ByteString(cbuf), EMPTY, tsz) + print hex(t) + ###-------------------------------------------------------------------------- ### Main program. @@ -763,6 +970,8 @@ MODEMAP = { 'eax-enc': (eaxgen, 3*[binarg] + [intarg], eaxenc), 'ocb1-dec': (dummygen, 4*[binarg], ocb1dec), 'ocb2-enc': (ocbgen, 3*[binarg] + [intarg], ocb2enc), 'ocb2-dec': (dummygen, 4*[binarg], ocb2dec), + 'ocb3-enc': (ocb3gen, 3*[binarg] + [intarg], ocb3enc), + 'ocb3-dec': (dummygen, 4*[binarg], ocb3dec), 'pmac1': (pmacgen, [binarg], pmac1_pub) } mode = argv[1] @@ -772,6 +981,15 @@ for d in CUSTOM, C.gcprps: except KeyError: pass else: break if bc is None: raise KeyError, argv[2] +if len(argv) == 5 and mode == 'ocb3-mct': + VERBOSE = False + ksz, tsz = int(argv[3]), int(argv[4]) + ocb3_mct(bc, ksz, tsz) + exit(0) +if len(argv) == 3 and mode == 'ocb3-mct2': + VERBOSE = False + ocb3_mct2(bc) + exit(0) if len(argv) == 3: VERBOSE = False gen, argty, func = MODEMAP[mode] -- 2.11.0