From 2964c388ff2dd177d1c4a49907904a785861f3a2 Mon Sep 17 00:00:00 2001 From: Mark Wooding Date: Wed, 31 Oct 2018 16:45:06 +0000 Subject: [PATCH] symm/eax.h, symm/eax-def.h: Implement the EAX authenticated encryption mode. --- symm/Makefile.am | 3 + symm/eax-def.h | 850 ++++++++++++++++++++++++++++++++++++++++++++++++++ symm/eax.h | 294 +++++++++++++++++ symm/t/blowfish | 147 +++++++++ symm/t/cast128 | 147 +++++++++ symm/t/cast256.local | 147 +++++++++ symm/t/des | 75 +++++ symm/t/des3 | 147 +++++++++ symm/t/desx | 147 +++++++++ symm/t/idea | 39 +++ symm/t/mars.local | 147 +++++++++ symm/t/noekeon | 39 +++ symm/t/rc2 | 147 +++++++++ symm/t/rc5 | 147 +++++++++ symm/t/rijndael.local | 213 +++++++++++++ symm/t/rijndael192 | 147 +++++++++ symm/t/rijndael256 | 147 +++++++++ symm/t/safer | 75 +++++ symm/t/safersk | 75 +++++ symm/t/serpent.local | 211 +++++++++++++ symm/t/skipjack | 39 +++ symm/t/square | 111 +++++++ symm/t/tea | 147 +++++++++ symm/t/twofish.local | 147 +++++++++ symm/t/xtea | 147 +++++++++ utils/advmodes | 68 +++- 26 files changed, 4001 insertions(+), 2 deletions(-) create mode 100644 symm/eax-def.h create mode 100644 symm/eax.h diff --git a/symm/Makefile.am b/symm/Makefile.am index 2af0945b..75ac7903 100644 --- a/symm/Makefile.am +++ b/symm/Makefile.am @@ -319,6 +319,9 @@ BLKCCIPHERMODES += counter ## CMAC mode. BLKCMACMODES += cmac +## Various AEAD modes. +BLKCAEADMODES += eax + ###-------------------------------------------------------------------------- ### Hash functions. diff --git a/symm/eax-def.h b/symm/eax-def.h new file mode 100644 index 00000000..6e1c7ca4 --- /dev/null +++ b/symm/eax-def.h @@ -0,0 +1,850 @@ +/* -*-c-*- + * + * The EAX authenticated-encryption mode + * + * (c) 2017 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_EAX_DEF_H +#define CATACOMB_EAX_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_CMAC_H +# include "cmac.h" +#endif + +#ifndef CATACOMB_CMAC_DEF_H +# include "cmac-def.h" +#endif + +#ifndef CATACOMB_KEYSZ_H +# include "keysz.h" +#endif + +#ifndef CATACOMB_PARANOIA_H +# include "paranoia.h" +#endif + +#ifndef CATACOMB_RSVR_H +# include "rsvr.h" +#endif + +/*----- Macros ------------------------------------------------------------*/ + +/* --- @EAX_DEF@ --- * + * + * Arguments: @PRE@, @pre@ = prefixes for the underlying block cipher + * + * Use: Creates an implementation for the EAX authenticated- + * encryption mode. + */ + +#define EAX_DEF(PRE, pre) EAX_DEFX(PRE, pre, #pre, #pre) + +#define EAX_DEFX(PRE, pre, name, fname) \ + \ +OMAC_DECL(PRE, pre) \ + \ +const octet \ + pre##_eaxnoncesz[] = { KSZ_ANY, PRE##_BLKSZ }, \ + pre##_eaxtagsz[] = { KSZ_RANGE, PRE##_BLKSZ, 0, PRE##_BLKSZ, 1 }; \ + \ +/* --- @pre_eaxsetkey@ --- * \ + * \ + * Arguments: @pre_eaxkey *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 EAX key block. \ + */ \ + \ +void pre##_eaxsetkey(pre##_eaxkey *key, const void *k, size_t ksz) \ +{ \ + uint32 t[PRE##_BLKSZ/4]; \ + \ + /* Initialize the block cipher. */ \ + pre##_init(&key->ctx, k, ksz); \ + \ + /* Set up the OMAC masks. */ \ + pre##_omacmasks(&key->ctx, key->m0, key->m1); \ + \ + /* Set up the OMAC tweaks. EAX tweaks its MAC by simply stitching \ + * magic block-wide prefixes %$t_0$%, %$t_1$%, %$t_2$% (which are \ + * simply the numbers 0, 1, 2) on the front of strings. We can \ + * accelerate things by caching two values for each tweak: \ + * \ + * * %$v_i = E_K(t_i)$% is the accumulator that results from \ + * pushing the tweak through the blockcipher, which we'd \ + * calculate if the original message was nonempty. \ + * \ + * * %$z_i = E_K(t_0 \xor m_0)$% is the tweak with the `full final \ + * buffer' mask applied, which is the final tag for a final empty \ + * message. \ + */ \ + BLKC_BSET(PRE, t, 0); pre##_eblk(&key->ctx, t, key->v0); \ + BLKC_XMOVE(PRE, t, key->m0); pre##_eblk(&key->ctx, t, key->z0); \ + BLKC_BSET(PRE, t, 1); pre##_eblk(&key->ctx, t, key->v1); \ + BLKC_XMOVE(PRE, t, key->m0); pre##_eblk(&key->ctx, t, key->z1); \ + BLKC_BSET(PRE, t, 2); pre##_eblk(&key->ctx, t, key->v2); \ + BLKC_XMOVE(PRE, t, key->m0); pre##_eblk(&key->ctx, t, key->z2); \ +} \ + \ +/* --- @pre_eaxaadinit@ --- * \ + * \ + * Arguments: @pre_eaxaadctx *aad@ = pointer to AAD context \ + * @const pre_eaxkey *key@ = pointer to key block \ + * \ + * Returns: --- \ + * \ + * Use: Initializes an EAX AAD (`additional authenticated \ + * data') context associated with 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, though \ + * usually there'll at least be another copy in some EAX \ + * operation context because the AAD on its own isn't much \ + * good. \ + */ \ + \ +void pre##_eaxaadinit(pre##_eaxaadctx *aad, const pre##_eaxkey *key) \ + { aad->k = *key; aad->off = 0; BLKC_MOVE(PRE, aad->a, key->v1); } \ + \ +/* --- @pre_eaxaadhash@ --- * \ + * \ + * Arguments: @pre_eaxaadctx *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. \ + */ \ + \ +void pre##_eaxaadhash(pre##_eaxaadctx *aad, const void *p, size_t sz) \ +{ \ + rsvr_state st; \ + const octet *q; \ + \ + rsvr_setup(&st, &pre##_omacpolicy, aad->b, &aad->off, p, sz); \ + RSVR_DO(&st) while ((q = RSVR_NEXT(&st, PRE##_BLKSZ)) != 0) \ + OMAC_BLOCK(PRE, pre, &aad->k.ctx, aad->a, q); \ +} \ + \ +/* --- @pre_eaxinit@ --- * \ + * \ + * Arguments: @pre_eaxctx *ctx@ = pointer to EAX context \ + * @const pre_eaxkey *key@ = pointer to key block \ + * @const void *n@ = pointer to nonce \ + * @size_t nsz@ = size of nonce \ + * \ + * Returns: --- \ + * \ + * Use: Initialize an EAX operation context with a given key. \ + * \ + * The original key needn't be kept around any more. \ + */ \ + \ +void pre##_eaxinit(pre##_eaxctx *ctx, const pre##_eaxkey *k, \ + const void *n, size_t nsz) \ + { ctx->k = *k; pre##_eaxreinit(ctx, n, nsz); } \ + \ +/* --- @pre_eaxreinit@ --- * \ + * \ + * Arguments: @pre_eaxctx *ctx@ = pointer to EAX context \ + * @const void *n@ = pointer to nonce \ + * @size_t nsz@ = size of nonce \ + * \ + * Returns: --- \ + * \ + * Use: Reinitialize an EAX operation context, changing the \ + * nonce. \ + */ \ + \ +void pre##_eaxreinit(pre##_eaxctx *ctx, const void *n, size_t nsz) \ +{ \ + octet b[PRE##_BLKSZ]; \ + const octet *q = n; \ + \ + /* Initialize the OMAC context with the right tweak. */ \ + BLKC_MOVE(PRE, ctx->a, ctx->k.v2); \ + ctx->off = 0; \ + \ + /* Calculate the initial counter from the nonce. This is OMAC again, \ + * but this time we know that we're starting from a clean slate and \ + * we have the whole input in one go, so we don't bother with the \ + * full reservoir machinery. \ + */ \ + if (!nsz) \ + BLKC_MOVE(PRE, ctx->c0, ctx->k.z0); \ + else { \ + BLKC_MOVE(PRE, ctx->c0, ctx->k.v0); \ + while (nsz > PRE##_BLKSZ) { \ + OMAC_BLOCK(PRE, pre, &ctx->k.ctx, ctx->c0, q); \ + q += PRE##_BLKSZ; nsz -= PRE##_BLKSZ; \ + } \ + memcpy(b, q, nsz); \ + pre##_omacdone(&ctx->k.ctx, ctx->k.m0, ctx->k.m1, \ + ctx->c0, b, nsz); \ + } \ + \ + /* We must remember the initial counter for the final tag \ + * calculation. (I conjecture that storing the final counter instead \ + * would be just as secure, and require less state, but I've not \ + * proven this, and anyway it wouldn't interoperate.) Copy it to \ + * make the working counter. \ + */ \ + BLKC_MOVE(PRE, ctx->c, ctx->c0); \ +} \ + \ +/* --- @pre_eaxencrypt@ --- * \ + * \ + * Arguments: @pre_eaxctx *ctx@ = pointer to EAX 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. \ + * \ + * For EAX, we always write a ciphertext chunk the same \ + * size as the plaintext. The messing about with @buf@ \ + * objects makes the interface consistent with other AEAD \ + * schemes which can't do this. \ + */ \ + \ +int pre##_eaxencrypt(pre##_eaxctx *ctx, \ + const void *src, size_t sz, buf *dst) \ +{ \ + rsvr_plan plan; \ + uint32 t[PRE##_BLKSZ/4]; \ + const octet *p = src; \ + octet *q, *r, y; \ + \ + /* Allocate space for the ciphertext. */ \ + if (sz) { q = buf_get(dst, sz); if (!q) return (-1); } \ + else q = 0; \ + \ + /* Determine the buffering plan. Our buffer is going to do double- \ + * duty here. The end portion is going to contain mask from the \ + * encrypted counter which we mix into the plaintext to encrypt it; \ + * the start portion, which originally mask bytes we've already used, \ + * will hold the output ciphertext, which will eventually be \ + * collected into the OMAC state. \ + */ \ + rsvr_mkplan(&plan, &pre##_omacpolicy, ctx->off, sz); \ + \ + /* Initial portion, fulfilled from the buffer. If the buffer is \ + * empty, then that means that we haven't yet encrypted the current \ + * counter, so we should do that and advance it. \ + */ \ + if (plan.head) { \ + if (!ctx->off) { \ + pre##_eblk(&ctx->k.ctx, ctx->c, t); BLKC_BSTEP(PRE, ctx->c); \ + BLKC_STORE(PRE, ctx->b, t); \ + } \ + r = ctx->b + ctx->off; ctx->off += plan.head; \ + while (plan.head--) { y = *p++ ^ *r; *r++ = *q++ = y; } \ + } \ + \ + /* If we've filled up the buffer then we need to cycle the MAC and \ + * reset the offset. \ + */ \ + if (plan.from_rsvr) { \ + OMAC_BLOCK(PRE, pre, &ctx->k.ctx, ctx->a, ctx->b); \ + ctx->off = 0; \ + } \ + \ + /* Now to process the main body of the input. We sneakily open-code \ + * the OMAC part of this. \ + */ \ + while (plan.from_input) { \ + pre##_eblk(&ctx->k.ctx, ctx->c, t); BLKC_BSTEP(PRE, ctx->c); \ + BLKC_XLOAD(PRE, t, p); p += PRE##_BLKSZ; \ + BLKC_STORE(PRE, q, t); q += PRE##_BLKSZ; \ + BLKC_XMOVE(PRE, ctx->a, t); pre##_eblk(&ctx->k.ctx, ctx->a, ctx->a); \ + plan.from_input -= PRE##_BLKSZ; \ + } \ + \ + /* Finally, deal with any final portion. If there is one, we know \ + * that the buffer is empty: we must have filled it above, or this \ + * would all count as `initial' data. \ + */ \ + if (plan.tail) { \ + pre##_eblk(&ctx->k.ctx, ctx->c, t); BLKC_BSTEP(PRE, ctx->c); \ + BLKC_STORE(PRE, ctx->b, t); \ + r = ctx->b; ctx->off += plan.tail; \ + while (plan.tail--) { y = *p++ ^ *r; *r++ = *q++ = y; } \ + } \ + \ + /* And we're done. */ \ + return (0); \ +} \ + \ +/* --- @pre_eaxdecrypt@ --- * \ + * \ + * Arguments: @pre_eaxctx *ctx@ = pointer to EAX 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. \ + * \ + * For EAX, we always write a plaintext chunk the same \ + * size as the ciphertext. The messing about with @buf@ \ + * objects makes the interface consistent with other AEAD \ + * schemes which can't do this. \ + */ \ + \ +int pre##_eaxdecrypt(pre##_eaxctx *ctx, \ + const void *src, size_t sz, buf *dst) \ +{ \ + rsvr_plan plan; \ + uint32 t[PRE##_BLKSZ/4], u[PRE##_BLKSZ]; \ + const octet *p = src; \ + octet *q, *r, y; \ + \ + /* Allocate space for the plaintext. */ \ + if (sz) { q = buf_get(dst, sz); if (!q) return (-1); } \ + else q = 0; \ + \ + /* Determine the buffering plan. Our buffer is going to do double- \ + * duty here. The end portion is going to contain mask from the \ + * encrypted counter which we mix into the plaintext to encrypt it; \ + * the start portion, which originally mask bytes we've already used, \ + * will hold the input ciphertext, which will eventually be \ + * collected into the OMAC state. \ + */ \ + rsvr_mkplan(&plan, &pre##_omacpolicy, ctx->off, sz); \ + \ + /* Initial portion, fulfilled from the buffer. If the buffer is \ + * empty, then that means that we haven't yet encrypted the current \ + * counter, so we should do that and advance it. \ + */ \ + if (plan.head) { \ + if (!ctx->off) { \ + pre##_eblk(&ctx->k.ctx, ctx->c, t); BLKC_BSTEP(PRE, ctx->c); \ + BLKC_STORE(PRE, ctx->b, t); \ + } \ + r = ctx->b + ctx->off; ctx->off += plan.head; \ + while (plan.head--) { y = *p++; *q++ = y ^ *r; *r++ = y; } \ + } \ + \ + /* If we've filled up the buffer then we need to cycle the MAC and \ + * reset the offset. \ + */ \ + if (plan.from_rsvr) { \ + OMAC_BLOCK(PRE, pre, &ctx->k.ctx, ctx->a, ctx->b); \ + ctx->off = 0; \ + } \ + \ + /* Now to process the main body of the input. We sneakily open-code \ + * the OMAC part of this. \ + */ \ + while (plan.from_input) { \ + pre##_eblk(&ctx->k.ctx, ctx->c, t); BLKC_BSTEP(PRE, ctx->c); \ + BLKC_LOAD(PRE, u, p); p += PRE##_BLKSZ; \ + BLKC_XSTORE(PRE, q, t, u); q += PRE##_BLKSZ; \ + BLKC_XMOVE(PRE, ctx->a, u); pre##_eblk(&ctx->k.ctx, ctx->a, ctx->a); \ + plan.from_input -= PRE##_BLKSZ; \ + } \ + \ + /* Finally, deal with any final portion. If there is one, we know \ + * that the buffer is empty: we must have filled it above, or this \ + * would all count as `initial' data. \ + */ \ + if (plan.tail) { \ + pre##_eblk(&ctx->k.ctx, ctx->c, t); BLKC_BSTEP(PRE, ctx->c); \ + BLKC_STORE(PRE, ctx->b, t); \ + r = ctx->b; ctx->off += plan.tail; \ + while (plan.tail--) { y = *p++; *q++ = y ^ *r; *r++ = y; } \ + } \ + \ + /* And we're done. */ \ + return (0); \ +} \ + \ +/* --- @pre_eaxtag@ --- * \ + * \ + * Arguments: @pre_eaxctx *ctx@ = pointer to an EAX context \ + * @const pre_eaxaadctx *aad@ = pointer to AAD context, or \ + * null \ + * @octet *t@ = where to write a (full-length) tag \ + * \ + * Returns: --- \ + * \ + * Use: Finishes an EAX operation, by calculating the tag. \ + */ \ + \ +static void pre##_eaxtag(pre##_eaxctx *ctx, \ + const pre##_eaxaadctx *aad, octet *t) \ +{ \ + octet b[PRE##_BLKSZ]; \ + uint32 u[PRE##_BLKSZ/4]; \ + \ + /* Finish tagging the ciphertext. (The buffer is empty if and only \ + * if there was no message, since the OMAC reservoir policy leaves \ + * the buffer full.) \ + */ \ + if (!ctx->off) BLKC_MOVE(PRE, ctx->a, ctx->k.z2); \ + else pre##_omacdone(&ctx->k.ctx, ctx->k.m0, ctx->k.m1, \ + ctx->a, ctx->b, ctx->off); \ + \ + /* If there's no AAD, because the pointer is null or no data was \ + * supplied, then use the cached empty-header tag. Otherwise \ + * calculate the tag for the AAD. Either way, mix the result into \ + * ctx->A, and be careful not to modify the AAD context. (Again, the \ + * buffer is empty if and only if there was no AAD.) \ + */ \ + if (!aad || !aad->off) BLKC_XMOVE(PRE, ctx->a, ctx->k.z1); \ + else { \ + BLKC_MOVE(PRE, u, aad->a); memcpy(b, aad->b, aad->off); \ + pre##_omacdone(&ctx->k.ctx, ctx->k.m0, ctx->k.m1, u, b, aad->off); \ + BLKC_XMOVE(PRE, ctx->a, u); \ + } \ + \ + /* Finally, mix in the initial counter value. */ \ + BLKC_XMOVE(PRE, ctx->a, ctx->c0); \ + \ + /* We're done. */ \ + BLKC_STORE(PRE, t, ctx->a); \ +} \ + \ +/* --- @pre_eaxencryptdone@ --- * \ + * \ + * Arguments: @pre_eaxctx *ctx@ = pointer to an EAX context \ + * @const pre_eaxaadctx *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 EAX encryption operation. The @aad@ \ + * pointer may be null if there is no additional \ + * authenticated data. EAX doesn't buffer ciphertext, but \ + * the output buffer is provided anyway for consistency \ + * with other AEAD schemes which don't have this property; \ + * the function will fail if the output buffer is broken. \ + */ \ + \ +int pre##_eaxencryptdone(pre##_eaxctx *ctx, \ + const pre##_eaxaadctx *aad, buf *dst, \ + void *tag, size_t tsz) \ +{ \ + octet t[PRE##_BLKSZ]; \ + \ + if (tsz > PRE##_BLKSZ) return (-1); \ + if (!BOK(dst)) return (-1); \ + pre##_eaxtag(ctx, aad, t); memcpy(tag, t, tsz); \ + return (0); \ +} \ + \ +/* --- @pre_eaxdecryptdone@ --- * \ + * \ + * Arguments: @pre_eaxctx *ctx@ = pointer to an EAX context \ + * @const pre_eaxaadctx *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 EAX decryption operation. The @aad@ \ + * pointer may be null if there is no additional \ + * authenticated data. EAX doesn't buffer plaintext, but \ + * the output buffer is provided anyway for consistency \ + * with other AEAD schemes which don't have this property; \ + * the function will fail if the output buffer is broken. \ + */ \ + \ +int pre##_eaxdecryptdone(pre##_eaxctx *ctx, \ + const pre##_eaxaadctx *aad, buf *dst, \ + const void *tag, size_t tsz) \ +{ \ + octet t[PRE##_BLKSZ]; \ + \ + if (tsz > PRE##_BLKSZ) return (-1); \ + if (!BOK(dst)) return (-1); \ + pre##_eaxtag(ctx, aad, t); \ + if (!ct_memeq(tag, t, tsz)) return (0); \ + else return (+1); \ +} \ + \ +/* --- Generic AEAD interface --- */ \ + \ +typedef struct gactx { \ + gaead_aad a; \ + pre##_eaxaadctx 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##_eaxaadhash(&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##_eax, gadup, gahash, gadestroy }; \ + \ +static gaead_aad *gaad(const pre##_eaxkey *k) \ +{ \ + gactx *aad = S_CREATE(gactx); \ + aad->a.ops = &gaops; \ + pre##_eaxaadinit(&aad->aad, k); \ + return (&aad->a); \ +} \ + \ +typedef struct gectx { \ + gaead_enc e; \ + pre##_eaxctx 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; \ + \ + if (tsz > PRE##_BLKSZ) return (-1); \ + pre##_eaxreinit(&enc->ctx, n, nsz); \ + return (0); \ +} \ + \ +static int geenc(gaead_enc *e, const void *m, size_t msz, buf *b) \ +{ \ + gectx *enc = (gectx *)e; \ + return (pre##_eaxencrypt(&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##_eaxencryptdone(&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##_eax, geaad, gereinit, geenc, gedone, gedestroy }; \ + \ +typedef struct gdctx { \ + gaead_dec d; \ + pre##_eaxctx 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; \ + \ + if (tsz > PRE##_BLKSZ) return (-1); \ + pre##_eaxreinit(&dec->ctx, n, nsz); \ + return (0); \ +} \ + \ +static int gddec(gaead_dec *d, const void *c, size_t csz, buf *b) \ +{ \ + gdctx *dec = (gdctx *)d; \ + return (pre##_eaxdecrypt(&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##_eaxdecryptdone(&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##_eax, gdaad, gdreinit, gddec, gddone, gddestroy }; \ + \ +typedef struct gkctx { \ + gaead_key k; \ + pre##_eaxkey 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; \ + \ + if (tsz > PRE##_BLKSZ) return (0); \ + enc = S_CREATE(gectx); enc->e.ops = &geops; \ + pre##_eaxinit(&enc->ctx, &key->key, n, nsz); \ + 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; \ + \ + if (tsz > PRE##_BLKSZ) return (0); \ + dec = S_CREATE(gdctx); dec->d.ops = &gdops; \ + pre##_eaxinit(&dec->ctx, &key->key, n, nsz); \ + return (&dec->d); \ +} \ + \ +static void gkdestroy(gaead_key *k) \ + { gkctx *key = (gkctx *)k; BURN(*key); S_DESTROY(key); } \ + \ +static const gaead_keyops gkops = \ + { &pre##_eax, gkaad, gkenc, gkdec, gkdestroy }; \ + \ +static gaead_key *gckey(const void *k, size_t ksz) \ +{ \ + gkctx *key = S_CREATE(gkctx); \ + key->k.ops = &gkops; \ + pre##_eaxsetkey(&key->key, k, ksz); \ + return (&key->k); \ +} \ + \ +const gcaead pre##_eax = { \ + name "-eax", \ + pre##_keysz, pre##_eaxnoncesz, pre##_eaxtagsz, \ + PRE##_BLKSZ, 0, 0, 0, \ + gckey \ +}; \ + \ +EAX_TESTX(PRE, pre, name, fname) + +/*----- Test rig ----------------------------------------------------------*/ + +#define EAX_TEST(PRE, pre) EAX_TESTX(PRE, pre, #pre, #pre) + +/* --- @EAX_TEST@ --- * + * + * Arguments: @PRE, pre@ = prefixes for the underlying block cipher + * + * Use: Standard test rig for EAX functions. + */ + +#ifdef TEST_RIG + +#include + +#include +#include +#include + +#define EAX_TESTX(PRE, pre, name, fname) \ + \ +static int eaxverify(dstr *v) \ +{ \ + pre##_eaxkey key; \ + pre##_eaxaadctx aad; \ + pre##_eaxctx 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##_eaxsetkey(&key, v[0].buf, v[0].len); \ + \ + for (ip = szs; *ip; ip++) { \ + \ + pre##_eaxinit(&ctx, &key, (octet *)v[1].buf, v[1].len); \ + \ + i = *ip; \ + hsz = v[2].len; \ + if (i == -1) i = hsz; \ + if (i > hsz) continue; \ + p = (octet *)v[2].buf; \ + pre##_eaxaadinit(&aad, &key); \ + while (hsz) { \ + if (i > hsz) i = hsz; \ + pre##_eaxaadhash(&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##_eaxencrypt(&ctx, p, i, &b)) { \ + puts("!! eaxencrypt reports failure"); \ + goto fail_enc; \ + } \ + p += i; msz -= i; \ + } \ + \ + if (pre##_eaxencryptdone(&ctx, &aad, &b, (octet *)t.buf, t.len)) { \ + puts("!! eaxencryptdone 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##_eaxinit(&ctx, &key, (octet *)v[1].buf, v[1].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##_eaxdecrypt(&ctx, p, i, &b)) { \ + puts("!! eaxdecrypt reports failure"); \ + win = 0; goto fail_dec; \ + } \ + p += i; msz -= i; \ + } \ + \ + win = pre##_eaxdecryptdone(&ctx, &aad, &b, \ + (octet *)v[5].buf, v[5].len); \ + if (win < 0) { \ + puts("!! eaxdecryptdone 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 test_chunk aeaddefs[] = { \ + { name "-eax", eaxverify, \ + { &type_hex, &type_hex, &type_hex, &type_hex, \ + &type_hex, &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 EAX_TESTX(PRE, pre, name, fname) +#endif + +/*----- That's all, folks -------------------------------------------------*/ + +#ifdef __cplusplus + } +#endif + +#endif diff --git a/symm/eax.h b/symm/eax.h new file mode 100644 index 00000000..0018da6d --- /dev/null +++ b/symm/eax.h @@ -0,0 +1,294 @@ +/* -*-c-*- + * + * The EAX authenticated-encryption mode + * + * (c) 2017 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 EAX ------------------------------------------------------* + * + * The name doesn't appear to be short for anything convincing. EAX was + * designed in 2004 by Mihir Bellare, Phillip Rogaway, and David Wagner, as a + * response to CCM's deficiencies, which Rogaway and Wagner had complained + * about the previous year. Like CCM, it's a patent-free authenticated + * encryption scheme based on counter mode and CBC-MAC, and needs two + * blockcipher applications per message block, but it's much more refined + * than CCM. The EAX specification is clear about how the mode applies to + * arbitrary block sizes, and I've not had to make any decisions on how to + * extend it myself. + * + * EAX allows arbitrarily sized nonces, and doesn't require precommitment to + * any lengths, and allows header data to be processed independently of any + * message. It's basically about as good as a rate-1/2 scheme is going to + * be. + */ + +#ifndef CATACOMB_EAX_H +#define CATACOMB_EAX_H + +#ifdef __cplusplus + extern "C" { +#endif + +/*----- Header files ------------------------------------------------------*/ + +#include + +#include +#include + +#ifndef CATACOMB_GAEAD_H +# include "gaead.h" +#endif + +/*----- Macros ------------------------------------------------------------*/ + +/* --- @EAX_DECL@ --- * + * + * Arguments: @PRE@, @pre@ = prefixes for the underlying block cipher + * + * Use: Creates declarations for EAX authenticated-encryption mode. + */ + +#define EAX_DECL(PRE, pre) \ + \ +typedef struct pre##_eaxkey { \ + pre##_ctx ctx; /* Block cipher key */ \ + uint32 m0[PRE##_BLKSZ/4], m1[PRE##_BLKSZ/4]; /* Final OMAC masks */ \ + uint32 v0[PRE##_BLKSZ/4], /* OMAC tweak accumulators */ \ + v1[PRE##_BLKSZ/4], v2[PRE##_BLKSZ/4]; \ + uint32 z0[PRE##_BLKSZ/4], /* Empty-message tag values */ \ + z1[PRE##_BLKSZ/4], z2[PRE##_BLKSZ/4]; \ +} pre##_eaxkey; \ + \ +typedef struct pre##_eaxaadctx { \ + pre##_eaxkey k; /* Underlying key */ \ + uint32 a[PRE##_BLKSZ/4]; /* OMAC accumulator */ \ + octet b[PRE##_BLKSZ]; /* Input buffer */ \ + unsigned off; /* Length of stuff in buffer */ \ +} pre##_eaxaadctx; \ + \ +typedef struct pre##_eaxctx { \ + /* The buffer is split into two portions. The first N octets hold a \ + * chunk of ciphertext, which will be fed into the OMAC calculation; \ + * the remaining BLKSZ - N octets hold E_K(C), which is the XOR mask \ + * to apply to the plaintext or ciphertext. \ + */ \ + pre##_eaxkey k; /* Underlying key */ \ + uint32 c[PRE##_BLKSZ/4]; /* Current counter value */ \ + uint32 c0[PRE##_BLKSZ/4]; /* Initial counter */ \ + uint32 a[PRE##_BLKSZ]; /* OMAC accumulator */ \ + octet b[PRE##_BLKSZ]; /* Ciphertext/mask buffer */ \ + unsigned off; /* Crossover point in buffer */ \ +} pre##_eaxctx; \ + \ +extern const octet pre##_eaxnoncesz[], pre##_eaxtagsz[]; \ + \ +/* --- @pre_eaxsetkey@ --- * \ + * \ + * Arguments: @pre_eaxkey *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 EAX key block. \ + */ \ + \ +extern void pre##_eaxsetkey(pre##_eaxkey */*key*/, \ + const void */*k*/, size_t /*ksz*/); \ + \ +/* --- @pre_eaxaadinit@ --- * \ + * \ + * Arguments: @pre_eaxaadctx *aad@ = pointer to AAD context \ + * @const pre_eaxkey *key@ = pointer to key block \ + * \ + * Returns: --- \ + * \ + * Use: Initializes an EAX AAD (`additional authenticated \ + * data') context associated with 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, though \ + * usually there'll at least be another copy in some EAX \ + * operation context because the AAD on its own isn't much \ + * good. \ + */ \ + \ +extern void pre##_eaxaadinit(pre##_eaxaadctx */*aad*/, \ + const pre##_eaxkey */*key*/); \ + \ +/* --- @pre_eaxaadhash@ --- * \ + * \ + * Arguments: @pre_eaxaadctx *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##_eaxaadhash(pre##_eaxaadctx */*aad*/, \ + const void */*p*/, size_t /*sz*/); \ + \ +/* --- @pre_eaxinit@ --- * \ + * \ + * Arguments: @pre_eaxctx *ctx@ = pointer to EAX context \ + * @const pre_eaxkey *key@ = pointer to key block \ + * @const void *n@ = pointer to nonce \ + * @size_t nsz@ = size of nonce \ + * \ + * Returns: --- \ + * \ + * Use: Initialize an EAX operation context with a given key. \ + * \ + * The original key needn't be kept around any more. \ + */ \ + \ +extern void pre##_eaxinit(pre##_eaxctx */*ctx*/, \ + const pre##_eaxkey */*k*/, \ + const void */*n*/, size_t /*nsz*/); \ + \ +/* --- @pre_eaxreinit@ --- * \ + * \ + * Arguments: @pre_eaxctx *ctx@ = pointer to EAX context \ + * @const void *n@ = pointer to nonce \ + * @size_t nsz@ = size of nonce \ + * \ + * Returns: --- \ + * \ + * Use: Reinitialize an EAX operation context, changing the \ + * nonce. \ + */ \ + \ +extern void pre##_eaxreinit(pre##_eaxctx */*ctx*/, \ + const void */*n*/, size_t /*nsz*/); \ + \ +/* --- @pre_eaxencrypt@ --- * \ + * \ + * Arguments: @pre_eaxctx *ctx@ = pointer to EAX 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. \ + * \ + * For EAX, we always write a ciphertext chunk the same \ + * size as the plaintext. The messing about with @buf@ \ + * objects makes the interface consistent with other AEAD \ + * schemes which can't do this. \ + */ \ + \ +extern int pre##_eaxencrypt(pre##_eaxctx */*ctx*/, \ + const void */*src*/, size_t /*sz*/, \ + buf */*dst*/); \ + \ +/* --- @pre_eaxdecrypt@ --- * \ + * \ + * Arguments: @pre_eaxctx *ctx@ = pointer to EAX 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. \ + * \ + * For EAX, we always write a plaintext chunk the same \ + * size as the ciphertext. The messing about with @buf@ \ + * objects makes the interface consistent with other AEAD \ + * schemes which can't do this. \ + */ \ + \ +extern int pre##_eaxdecrypt(pre##_eaxctx */*ctx*/, \ + const void */*src*/, size_t /*sz*/, \ + buf */*dst*/); \ + \ +/* --- @pre_eaxencryptdone@ --- * \ + * \ + * Arguments: @pre_eaxctx *ctx@ = pointer to an EAX context \ + * @const pre_eaxaadctx *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 EAX encryption operation. The @aad@ \ + * pointer may be null if there is no additional \ + * authenticated data. EAX doesn't buffer ciphertext, but \ + * the output buffer is provided anyway for consistency \ + * with other AEAD schemes which don't have this property; \ + * the function will fail if the output buffer is broken. \ + */ \ + \ +extern int pre##_eaxencryptdone(pre##_eaxctx */*ctx*/, \ + const pre##_eaxaadctx */*aad*/, \ + buf */*dst*/, \ + void */*tag*/, size_t /*tsz*/); \ + \ +/* --- @pre_eaxdecryptdone@ --- * \ + * \ + * Arguments: @pre_eaxctx *ctx@ = pointer to an EAX context \ + * @const pre_eaxaadctx *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 EAX decryption operation. The @aad@ \ + * pointer may be null if there is no additional \ + * authenticated data. EAX doesn't buffer plaintext, but \ + * the output buffer is provided anyway for consistency \ + * with other AEAD schemes which don't have this property; \ + * the function will fail if the output buffer is broken. \ + */ \ + \ +extern int pre##_eaxdecryptdone(pre##_eaxctx */*ctx*/, \ + const pre##_eaxaadctx */*aad*/, \ + buf */*dst*/, \ + const void */*tag*/, size_t /*tsz*/); \ + \ +/* --- Generic AEAD interface --- */ \ + \ +extern const gcaead pre##_eax; + +/*----- That's all, folks -------------------------------------------------*/ + +#ifdef __cplusplus + } +#endif + +#endif diff --git a/symm/t/blowfish b/symm/t/blowfish index 67520166..a9a066f6 100644 --- a/symm/t/blowfish +++ b/symm/t/blowfish @@ -168,3 +168,150 @@ blowfish-cmac { bdff3bcd211499268878dbf30f1dad89d4b9b1 a54fb7e239aeec4c; } + +blowfish-eax { + 60d7bcda163547d348b7551195e77022907dd1dff7dac5c9941d26d0c6eb14ad568f86edd1dc9268eeee533285a6ed810c9b689daaa906 + "" + "" + "" + "" + a6e2fbebaf974200; + 0d2d4b6003062365b0a54364c76c160f11896c4794846ecfa14a7130c9f137120634c9519848a877ff77bf79192a5b50ade5d9cd739a3d + 1f + "" + "" + "" + 4cc58c2f4cf91137; + 337f29549e6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e + "" + 60 + "" + "" + c35fc08fda46f599; + 57acc87638f508046733d9ff61cdbda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb95295 + "" + "" + 33 + 9c + b7c0dcb87a8b86c9; + 966f27043eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030 + 370c33d090c54215 + abd6b3ad54efc9a38378c5b93bf4f2aad2605faee2b03fb6 + 48e27fff63102758fe2b69ac26afa3349829b94586306fed + 783ab2ee6ea73b63906caf73ceb4376b2e9ebee34fc490c5 + 3fff7a36718ab82c; + 54154f8f28523c03d4de1600157846b710ee72807a2219bfb474fd71d891f24bb65d1563259f9eb53b571ea629c54d57dd2d42f70800df + 9fcbaca48b77db + a189196d1ebba10b0467cb9fc2712a199e533f + a9156308cdec3f768281e040a9b9a222bd689aef66f5306ceb0c6b08ac + 43bfef92d8c8ba5641fb2523e92ef24d60a41da2e8bb3112aee7b80ce3 + 07ad2ca904227df7; + 8b0a22260c571b4a42bb8f + "" + "" + "" + "" + bd94df689662060a; + db233bfa6a5cfb0bad7d95 + 21 + "" + "" + "" + a43ffffe35e1b8a4; + 4ade49cb3b6f5fe8368131 + "" + 11 + "" + "" + d32da332498a6950; + 5c037ba323fe1dc8151784 + "" + "" + 87 + 12 + 0943c4cb5e3fc7eb; + 3f0eb5b647da6794c18b53 + 37685a96ed65b9ac + a338527ef19b09c063c46f88de9fd41e72d7b97e23e6eabd + ff3bcd211499268878dbf30f1dad89d4b9b12012e4713df4 + aebee82a01e138a7229636ee0eb746f6ce13584936f56bb4 + 5bddd65c9a111ec7; + 6795630e7952d22bb02d71 + 00b8b649377d20 + a8f083455b663e4ee1315f3c8f2aebfa921451 + dcd1af5813b70d30ce2f1fef6ef315d0798391805da08da3aefc5f8584 + 8a298eafedf8c1e183dfa50569cda59c9f93e56fde173e750e2fa185c7 + 78a05a55f474688a; + b7c5e61766 + "" + "" + "" + "" + 6e8da28b2d84682a; + 9c0f16e398 + 15 + "" + "" + "" + a6660ae3f78c52b7; + d4e9cfce3e + "" + d1 + "" + "" + caa08d52fd0d87cf; + ecdf3d264a + "" + "" + 7f + b7 + af92632b8a903cfd; + 16cb16c2e8 + 15f422cdf0c8e303 + 08be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69 + a4cd52147ed12ca986981a874498ad0abef8bc4fcb70e27e + 773aeb0f1ffbc8b9f0a642275761a79598ab37c4a531e157 + 7b4483789e1768fc; + 98ef1f0446 + b42fb144d44b6d + 00f06dc188d472a784e0c6f21195a3b9f4ae98 + 5511265febd11c164720eef9eb1c8dd0b00951f284649016ed00456331 + 08d772c882d1d700f980b349e40c3cb563743f62b966fe38ce39831c37 + 62662279f37c6a9b; + 854bc78bf43966eb0cfa9138ddc39908445608fe95e81c + "" + "" + "" + "" + 99eb415cd27dfb9d; + 2533e31c9c1a9851bc2810d858cbbc8424d126b807e6da + a0 + "" + "" + "" + c90ad3bb5ff737a9; + 89c3f9099c5ffb824173d7634c04226f30cbb7f0e4a973 + "" + a8 + "" + "" + dc32c7a1d4f99131; + cd190107314717a77456f3ff669c732b58db8f48af65f7 + "" + "" + cc + 86 + 5a32c09bf86a0f69; + 9e3fb90e1721b730374ffc9bc597f56ccbb2f294b38766 + fc69f6a9f2c0945f + fd505003cc0cae9ce021a5f1fa4ffa91544485f1a1258b2b + 9b8f0911e32d65cc1770a18cbfe6effd1ff6778554acf127 + c9d09215bfda6368733b83186710d656bd900f072a02173d + 1e35ed44860e1cb0; + 0485b203a3c1c4c967c0a458cb948bdd409b687fa3a682 + 7b480aa3a4c84c + ef64f6c9b53bf8f957f4b03cf43e89957f9a3e + 8128f8743d16687b7bb8deb9bd205b70e04c091d205cdad9e9a79b1abf + 1b485cb8f21d2744e6fdb19989d90693a8d2b935d0eae05facba546e91 + 8b86611191b4bdf3; +} diff --git a/symm/t/cast128 b/symm/t/cast128 index 8f763281..2940fdb2 100644 --- a/symm/t/cast128 +++ b/symm/t/cast128 @@ -64,3 +64,150 @@ cast128-cmac { ff63102758fe2b69ac26afa3349829b9458630 10bd2c18c3337a4f; } + +cast128-eax { + 60d7bcda163547d348b7551195 + "" + "" + "" + "" + de756459eefbe735; + e77022907dd1dff7dac5c9941d + 26 + "" + "" + "" + 706c2756289404eb; + d0c6eb14ad568f86edd1dc9268 + "" + ee + "" + "" + 1dba9d384981a899; + ee533285a6ed810c9b689daaa9 + "" + "" + 06 + 9c + e1c1cb285fe6fd42; + 0d2d4b6003062365b0a54364c7 + 6c160f11896c4794 + 846ecfa14a7130c9f137120634c9519848a877ff77bf7919 + 2a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085 + 7ea32c98c18f380ebf49a8153a036aba80fc8219ee85ea9a + 678b76a28d6415ac; + 406a6136512061f7080cc07df0 + 591d8fa21f2dd8 + 8374d8cde8e160ad10997a21635c6d62c92690 + 29df3e6057acc87638f508046733d9ff61cdbda3b3e9878731ebfedd47 + 21ed0355fd3256ebee4847ec0d0f6a024e6ea0f2cd8a5de1f5bb139385 + d4a1d384f6234b97; + 05e505da1435dc + "" + "" + "" + "" + cbbb9ef570741e49; + eaa7b1cc49ae1d + 50 + "" + "" + "" + f8c34e199b130f87; + c38201a894476b + "" + 3f + "" + "" + 76bfe7342f08a0d9; + 102b752eb95295 + "" + "" + 33 + 40 + 78d8ced34fba2669; + 966f27043eb621 + b7f65b000961040e + f2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215e + b57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215 + 2ab0a37f0ebd0523111d8079b33285016f8038eb01d8c726 + 2557d7fde2b5cbf4; + abd6b3ad54efc9 + a38378c5b93bf4 + f2aad2605faee2b03fb648e27fff63102758fe + 2b69ac26afa3349829b94586306fed54154f8f28523c03d4de16001578 + cde7aba02b6c423e5a4c5bee6592a8c6beedd60b458982ecb96ec2d05a + 4b957468a1b84eaf; + 46b710ee72807a2219bf + "" + "" + "" + "" + 4c34faee63cc6ded; + b474fd71d891f24bb65d + 15 + "" + "" + "" + fe3d9bc8bb1fadc7; + 63259f9eb53b571ea629 + "" + c5 + "" + "" + 89349e8fa6362b16; + 4d57dd2d42f70800df9f + "" + "" + cb + f0 + 3f45042252ade21c; + aca48b77dba189196d1e + bba10b0467cb9fc2 + 712a199e533fa9156308cdec3f768281e040a9b9a222bd68 + 9aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb23 + b5c79faaecf9c2d65703aae2c578b606b455c25f6aec3a4b + fe3a14a18c793f8d; + 3bfa6a5cfb0bad7d9521 + 4ade49cb3b6f5f + e8368131115c037ba323fe1dc8151784873f0e + b5b647da6794c18b5337685a96ed65b9aca338527ef19b09c063c46f88 + b8d413238c76153b01f0a2823e24414f91988638bf3a80cdb6a211700f + 12e4967ff0500b9f; + de9fd41e72d7b97e23 + "" + "" + "" + "" + caab65ebca9b09cd; + e6eabdff3bcd211499 + 26 + "" + "" + "" + 7fb3ef6dc33a52ea; + 8878dbf30f1dad89d4 + "" + b9 + "" + "" + 1781664543c4675f; + b12012e4713df46795 + "" + "" + 63 + 41 + 9d8c48bc137b207a; + 0e7952d22bb02d7100 + b8b649377d20a8f0 + 83455b663e4ee1315f3c8f2aebfa921451dcd1af5813b70d + 30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5 + bf81b5c1007332ff360b167545ff826c131e6279a40ec6f3 + e037dbce43a14ff2; + e617669c0f16e39815 + d4e9cfce3ed1ec + df3d264a7f16cb16c2e815f422cdf0c8e30308 + be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed1 + 9b3b606592501407cf47aa56b3136cca02d94d282ebf6d5f441b32b9f3 + d8a34c6cae422b2c; +} diff --git a/symm/t/cast256.local b/symm/t/cast256.local index cde1a905..7aec70ee 100644 --- a/symm/t/cast256.local +++ b/symm/t/cast256.local @@ -50,3 +50,150 @@ cast256-cmac { 1e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89d4b9b12012e4713df46795630e7952d22bb02d 4e21bb0835d28d84b50e6db35757d672; } + +cast256-eax { + 60d7bcda163547d348b7551195 + "" + "" + "" + "" + 2b961641462baf0a23af6720a9197d0a; + e77022907dd1dff7dac5c9941d + 26 + "" + "" + "" + c27ec7e5c6e5b2c0722a835e433f5708; + d0c6eb14ad568f86edd1dc9268 + "" + ee + "" + "" + 91ee71af24a201bdc7dba1596261eced; + ee533285a6ed810c9b689daaa9 + "" + "" + 06 + 36 + 21caca7994e9579e303e7c24be9fdb7f; + 0d2d4b6003062365b0a54364c7 + 6c160f11896c4794846ecfa14a7130c9 + f137120634c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7 + 080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e6057acc87638f508046733d9ff61 + 242810649692db21e7595173fad46df3f55019d4e719ceb5bc09a733997fcacc846e6ec1e0589e4c9e5355dfaace122f + 4039884385c992be1a778520915dc0d6; + cdbda3b3e9878731ebfedd4705 + e505da1435dceaa7b1cc49ae1d50c3 + 8201a894476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde + 52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93bf4f2aad260 + 6536f3d0bd3929eb609818c1cee5e2be47a1a02f0f883c34867f9966cfe97a31b2fd4c821c520e1be3d0a736dd1661b6190e24c1a6 + 33856bece05f1ca8fe19b530e407b966; + 5faee2b03fb648e27fff6310 + "" + "" + "" + "" + ee2162ee6e8410aa5200171d0c4024aa; + 2758fe2b69ac26afa3349829 + b9 + "" + "" + "" + 87a91471cda81dd33d9b42545c8b0b8c; + 4586306fed54154f8f28523c + "" + 03 + "" + "" + 0e5e8f75620078311d835458946c93ff; + d4de1600157846b710ee7280 + "" + "" + 7a + a6 + 18d59976b1087c9b1790cc5e6b29d3ff; + 2219bfb474fd71d891f24bb6 + 5d1563259f9eb53b571ea629c54d57dd + 2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f768281e040a9b9a222 + bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe836813111 + 303058fd583dbf8ab83aff89f31060650b03148c7330a6be6858eb1d384bac97798c4211f919b1170b2c1ce6d3d8b0da + 60ec12a7a132b714707aa1bfca3f3d67; + 5c037ba323fe1dc815178487 + 3f0eb5b647da6794c18b5337685a96 + ed65b9aca338527ef19b09c063c46f88de9fd41e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89 + d4b9b12012e4713df46795630e7952d22bb02d7100b8b649377d20a8f083455b663e4ee1315f3c8f2aebfa921451dcd1af5813b70d + efd6f1f344975f001595f2d1e3254791c4f1054f4e0932a85a28c1296308bad1c38aa7c2b2be16f2b14b94de98ce44d0255979ed5f + 335688afe647757a98f871ebf99933b7; + 30ce2f1fef6ef315 + "" + "" + "" + "" + 57a1e64ab9765509b8abd4c36b616844; + d0798391805da08d + a3 + "" + "" + "" + 9b3d0bae4a9f3fc0cc4135d73b6471e7; + aefc5f8584b7c5e6 + "" + 17 + "" + "" + 7a3a4fd12ec71c3058d3edc4416d6e56; + 669c0f16e39815d4 + "" + "" + e9 + 31 + f15c15c0e14893b05d599ec77547c893; + cfce3ed1ecdf3d26 + 4a7f16cb16c2e815f422cdf0c8e30308 + be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed12ca986981a874498ad0abef8bc4fcb70e27e98 + ef1f0446b42fb144d44b6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb1c8dd0b009 + dab10d1acc2f9596d131f83d22dfcb5f76e3133ae715429bb9ae30c6c41b4035ea2ba2e6d2b7afd41ffb821b88b0f11b + 2b770827aad8b1bfdf838506622ea7d6; + 51f284649016ed00 + 456331854bc78bf43966eb0cfa9138 + ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb82 + 4173d7634c04226f30cbb7f0e4a973a8cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e3fb90e1721b730374ffc9bc5 + 180b3ae40e896c401aa0ec3a9323a97b3063486d3016f504ba931948fe5f48455bee3defdcec5d43d2e5b96f021f45027bf304c4a7 + 36388109db5182725e7dc0c9e8c18e18; + 97f56ccbb2f294b38766fc69f6a9f2c094 + "" + "" + "" + "" + 65d71bd58e0cfc24609eb320f26c4144; + 5ffd505003cc0cae9ce021a5f1fa4ffa91 + 54 + "" + "" + "" + 5c3f108cadaeed7fdc40c74003074e4a; + 4485f1a1258b2b9b8f0911e32d65cc1770 + "" + a1 + "" + "" + deb0b205c88084de69e4dcd20f94372f; + 8cbfe6effd1ff6778554acf1270485b203 + "" + "" + a3 + 7d + e854cf62bc9c693207ab3c89432f5418; + c1c4c967c0a458cb948bdd409b687fa3a6 + 827b480aa3a4c84cef64f6c9b53bf8f9 + 57f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605ac + 8451399587011677508a15dde524af3e2bee0646541a42c2ecccb44d65bad397abfaf529ee41cf9a05c7efedef340153 + c8b37bf62703385c9441e1cdf357875ee437a15798e10c0717aefa605227bfffe401cfc610ae0b51d9f63e8098cc45bd + 4e68c56bb64b3d6ac08e35248a671884; + 9c51d2a90bbf7f1bfc338ab0ef5746ea8f + dcccd213e33f7e8a5718fd25014107 + c8e7d715a92add9589d1f5c054b2d983514605ec590294a319b9802068a9f891bc5ba5afabf8c3122d12d7 + ff3c41122d70d17d4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7ab + 3afadb7496af2b3d618391fb535d6c6b42cb20a259c0f2d359d83055062b3f3c8715fbe13fe3b001c254ded295b2225e461ce11d2c + 77dafdf4ffbffd0bafdc4b2a1c2a77f8; +} diff --git a/symm/t/des b/symm/t/des index 61934c4b..27afbef4 100644 --- a/symm/t/des +++ b/symm/t/des @@ -87,3 +87,78 @@ des-cmac { 36512061f7080cc07df0591d8fa21f2dd88374 2b5a2cec413de519; } + +des-eax { + bef260d7bcda1635 + "" + "" + "" + "" + 4fd7b7ceb605971d; + 47d348b7551195e7 + 70 + "" + "" + "" + 362aa5d62008f0b2; + 22907dd1dff7dac5 + "" + c9 + "" + "" + da21b21da7d57854; + 941d26d0c6eb14ad + "" + "" + 56 + 01 + 91d13047c75395e9; + 8f86edd1dc9268ee + ee533285a6ed810c + 9b689daaa9060d2d4b6003062365b0a54364c76c160f1189 + 6c4794846ecfa14a7130c9f137120634c9519848a877ff77 + ff6584338c84f608f20f9b45387b79f759e4bbffdb97a914 + a58397ff608476d2; + bf79192a5b50ade5 + d9cd739a3d1f33 + 7f29549e6b0d27a4ba234085406a6136512061 + f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62 + af4d58477434a67a527bd0abfbed0edc0e1d65db63ce387eee315f026a + e566a58b1afd6dde; + c9269029df3e60 + "" + "" + "" + "" + ce840f6919760b2f; + 57acc87638f508 + 04 + "" + "" + "" + d2004b1898772d24; + 6733d9ff61cdbd + "" + a3 + "" + "" + 7280bac984631a8b; + b3e9878731ebfe + "" + "" + dd + e8 + 75dd11b7cf5f0dae; + 4705e505da1435 + dceaa7b1cc49ae1d + 50c38201a894476b3f102b752eb9529533966f27043eb621 + b7f65b000961040ef2f9b2fc5fa450727a9b542cde52ebfd + 5cdd7720adf593db701494fc78e1bbd48e8fb79727cf09ad + b5c7ced07cae4060; + a19d0ccc520f21 + 5eb57bb3a4f3eb + bbb18ac6c95a97a48030370c33d090c54215ab + d6b3ad54efc9a38378c5b93bf4f2aad2605faee2b03fb648e27fff6310 + df23153076ea552eabc472d40d9c4e859e707cb2acc2d8aa7e828b949b + 01fcd2f2e30d870c; +} diff --git a/symm/t/des3 b/symm/t/des3 index b441d690..71cd9f80 100644 --- a/symm/t/des3 +++ b/symm/t/des3 @@ -119,3 +119,150 @@ des3-cmac { 8b77dba189196d1ebba10b0467cb9fc2712a19 2753a7135b48898f; } + +des3-eax { + 60d7bcda163547d348b7551195e7 + "" + "" + "" + "" + fb8989aca27d4e49; + 7022907dd1dff7dac5c9941d26d0 + c6 + "" + "" + "" + d6928baa49d00fad; + eb14ad568f86edd1dc9268eeee53 + "" + 32 + "" + "" + 33a565f808e5486a; + 85a6ed810c9b689daaa9060d2d4b + "" + "" + 60 + 79 + a70d6c7cd5e64642; + 03062365b0a54364c76c160f1189 + 6c4794846ecfa14a + 7130c9f137120634c9519848a877ff77bf79192a5b50ade5 + d9cd739a3d1f337f29549e6b0d27a4ba234085406a613651 + 9df7de45b395c138ed3f1c47399d41e00bad9d29625f6cbb + ffe26f440f8c69d8; + 2061f7080cc07df0591d8fa21f2d + d88374d8cde8e1 + 60ad10997a21635c6d62c9269029df3e6057ac + c87638f508046733d9ff61cdbda3b3e9878731ebfedd4705e505da1435 + 698d38628b4297877182f76af79b7a17fafba3580f403a1c0645416006 + 056a29aa5eec7e3b; + dceaa7b1cc49ae1d + "" + "" + "" + "" + cca6200e06749307; + 50c38201a894476b + 3f + "" + "" + "" + 71f50318e1a16b5d; + 102b752eb9529533 + "" + 96 + "" + "" + b553cae3d6e4ccb5; + 6f27043eb621b7f6 + "" + "" + 5b + eb + 6f6d185a5644e5dc; + 000961040ef2f9b2 + fc5fa450727a9b54 + 2cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c9 + 5a97a48030370c33d090c54215abd6b3ad54efc9a38378c5 + 02f9df6832af2567bb074a96ff52ff9ef27cb6df55ed6912 + 6919ed7c6d0c9686; + b93bf4f2aad2605f + aee2b03fb648e2 + 7fff63102758fe2b69ac26afa3349829b94586 + 306fed54154f8f28523c03d4de1600157846b710ee72807a2219bfb474 + 332681d1ab4ad4e8eee4f4b578efee58c917514f4d3c8ca33f50281a53 + 863ec2f3f702fa3a; + fd71d891f24bb65d1563259f9eb53b57 + "" + "" + "" + "" + 80199187ffd10cea; + 1ea629c54d57dd2d42f70800df9fcbac + a4 + "" + "" + "" + 54afba7a1543f424; + 8b77dba189196d1ebba10b0467cb9fc2 + "" + 71 + "" + "" + 9cb93469265f4d14; + 2a199e533fa9156308cdec3f768281e0 + "" + "" + 40 + 80 + e97aceb64f2af2bb; + a9b9a222bd689aef66f5306ceb0c6b08 + ac8b0a22260c571b + 4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8 + 368131115c037ba323fe1dc8151784873f0eb5b647da6794 + e9d68e86a6b48c7d9c78122bda02edc1b1419cb3031c60e4 + 57fcc7556b89f2a9; + c18b5337685a96ed65b9aca338527ef1 + 9b09c063c46f88 + de9fd41e72d7b97e23e6eabdff3bcd21149926 + 8878dbf30f1dad89d4b9b12012e4713df46795630e7952d22bb02d7100 + f89817786143348d71bd1ee8d1016e7256a94589b86a3ce582d7a9a374 + 0add4b3bd1159ff5; + b8b649377d20a8f083455b663e4ee1315f3c8f2aeb + "" + "" + "" + "" + f7c8ae1e42180c1a; + fa921451dcd1af5813b70d30ce2f1fef6ef315d079 + 83 + "" + "" + "" + b1dce877e070e318; + 91805da08da3aefc5f8584b7c5e617669c0f16e398 + "" + 15 + "" + "" + e373707f027e7557; + d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cd + "" + "" + f0 + ef + b49b83dc48872748; + c8e30308be3c31e6bc58c0b7cadcb658b970e47479 + a684b5aefa69a4cd + 52147ed12ca986981a874498ad0abef8bc4fcb70e27e98ef + 1f0446b42fb144d44b6d00f06dc188d472a784e0c6f21195 + 81e03369c6ecf1d8fb8c84a9817e0481b6de9ab9312737a4 + f9ad8a3df2d97500; + a3b9f4ae985511265febd11c164720eef9eb1c8dd0 + b00951f2846490 + 16ed00456331854bc78bf43966eb0cfa9138dd + c39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126 + d05f8c73aa124cdfe56cd74db66498169f829858ed7ad4366d6388f6ae + 1a54e1c0b2765dd8; +} diff --git a/symm/t/desx b/symm/t/desx index 03af5fda..e5ec5c16 100644 --- a/symm/t/desx +++ b/symm/t/desx @@ -71,3 +71,150 @@ desx-cmac { 67cb9fc2712a199e533fa9156308cdec3f7682 ebda61b856727ef6; } + +desx-eax { + 60d7bcda163547d348b7551195e770 + "" + "" + "" + "" + ee1840d22093ec87; + 22907dd1dff7dac5c9941d26d0c6eb + 14 + "" + "" + "" + 46bb7bcd888d7699; + ad568f86edd1dc9268eeee533285a6 + "" + ed + "" + "" + 64df2aefb68d65ae; + 810c9b689daaa9060d2d4b60030623 + "" + "" + 65 + bb + 575efecd423272be; + b0a54364c76c160f11896c4794846e + cfa14a7130c9f137 + 120634c9519848a877ff77bf79192a5b50ade5d9cd739a3d + 1f337f29549e6b0d27a4ba234085406a6136512061f7080c + 2972fa4117846aea7de02f73eb27981c4b72524b1d8bfb72 + abd123bd49b7e2e9; + c07df0591d8fa21f2dd88374d8cde8 + e160ad10997a21 + 635c6d62c9269029df3e6057acc87638f50804 + 6733d9ff61cdbda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49 + 35a431ef317b963514e1de6dfb568191eaa1bc89028e5868bcd25a8a3c + 2693b4f76100e1df; + ae1d50c38201a894 + "" + "" + "" + "" + c9fb343d394b7356; + 476b3f102b752eb9 + 52 + "" + "" + "" + 47b15722772ba414; + 9533966f27043eb6 + "" + 21 + "" + "" + 0d4b68956fb6f426; + b7f65b000961040e + "" + "" + f2 + dd + 8371e2b42301e2b0; + f9b2fc5fa450727a + 9b542cde52ebfda1 + 9d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a4803037 + 0c33d090c54215abd6b3ad54efc9a38378c5b93bf4f2aad2 + c199728a8cd014558621fcda5a5ce7765ba3770b43832210 + 84815299c2507a60; + 605faee2b03fb648 + e27fff63102758 + fe2b69ac26afa3349829b94586306fed54154f + 8f28523c03d4de1600157846b710ee72807a2219bfb474fd71d891f24b + bd352eea02065aa6352132121df385b3135e6598f1bbb589ed2c6044f1 + 6993814a37fada84; + b65d1563259f9eb53b571ea629c54d57 + "" + "" + "" + "" + 0a53de56ab1af32b; + dd2d42f70800df9fcbaca48b77dba189 + 19 + "" + "" + "" + 2539d47126f0cf9f; + 6d1ebba10b0467cb9fc2712a199e533f + "" + a9 + "" + "" + 395bc02e7eefec9a; + 156308cdec3f768281e040a9b9a222bd + "" + "" + 68 + ba + eb13f2c72c06d835; + 9aef66f5306ceb0c6b08ac8b0a22260c + 571b4a42bb8fdb23 + 3bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c03 + 7ba323fe1dc8151784873f0eb5b647da6794c18b5337685a + be11a99ec28d932e8064d57a7d3b6530cb137b8c05c397f2 + 9e116a03c63831e0; + 96ed65b9aca338527ef19b09c063c46f + 88de9fd41e72d7 + b97e23e6eabdff3bcd211499268878dbf30f1d + ad89d4b9b12012e4713df46795630e7952d22bb02d7100b8b649377d20 + 87f8e65dcf6034314eba4a952e6a6d0fc7595318f0cde2ba027276421e + 0c029e501b79f342; + a8f083455b663e4ee1315f3c8f2aebfa921451dcd1af58 + "" + "" + "" + "" + f784fa0ed911d8ec; + 13b70d30ce2f1fef6ef315d0798391805da08da3aefc5f + 85 + "" + "" + "" + 14998b9f57e85a91; + 84b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d264a + "" + 7f + "" + "" + eaad2aaf758ba8cb; + 16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0b7ca + "" + "" + dc + c6 + 05378e1a70ab191a; + b658b970e47479a684b5aefa69a4cd52147ed12ca98698 + 1a874498ad0abef8 + bc4fcb70e27e98ef1f0446b42fb144d44b6d00f06dc188d4 + 72a784e0c6f21195a3b9f4ae985511265febd11c164720ee + c5f5009fdbade4e487e8440429fc86aa782937bcdec0ca08 + 6feaef25c63b0802; + f9eb1c8dd0b00951f284649016ed00456331854bc78bf4 + 3966eb0cfa9138 + ddc39908445608fe95e81c2533e31c9c1a9851 + bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c + bf860edf5f2e423766bd979b97a8b90082ad8f015e2c24997603fe75e7 + 783c8dbade8c11f5; +} diff --git a/symm/t/idea b/symm/t/idea index 4853f84d..60f620bd 100644 --- a/symm/t/idea +++ b/symm/t/idea @@ -39,3 +39,42 @@ idea-cmac { 120634c9519848a877ff77bf79192a5b50ade5 c17895f93dd73a8a; } + +idea-eax { + e4bef260d7bcda163547d348b7551195 + "" + "" + "" + "" + 2ed1b711b35815fc; + e77022907dd1dff7dac5c9941d26d0c6 + eb + "" + "" + "" + e16c2e8dcbe82476; + 14ad568f86edd1dc9268eeee533285a6 + "" + ed + "" + "" + d71cbbb104ef47b6; + 810c9b689daaa9060d2d4b6003062365 + "" + "" + b0 + 93 + f9fa771344725555; + a54364c76c160f11896c4794846ecfa1 + 4a7130c9f1371206 + 34c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f33 + 7f29549e6b0d27a4ba234085406a6136512061f7080cc07d + cfcb5b76771f439b7e31a9503bc42213efcb50281711c0e0 + e70f4193b0a49031; + f0591d8fa21f2dd88374d8cde8e160ad + 10997a21635c6d + 62c9269029df3e6057acc87638f508046733d9 + ff61cdbda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50 + dfd640ccfb02298e9bdb44464e210bb5039e2fcfdf99a07198b5a41744 + 8100822295ddbb3c; +} diff --git a/symm/t/mars.local b/symm/t/mars.local index 941b70bd..b1d31b7f 100644 --- a/symm/t/mars.local +++ b/symm/t/mars.local @@ -50,3 +50,150 @@ mars-cmac { 9c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0b7cadcb6 797407de4940048d366f408567a0b4ca; } + +mars-eax { + 60d7bcda163547d348b75511 + "" + "" + "" + "" + 783e4c5710aa46926fa54c1810e7e73f; + 95e77022907dd1dff7dac5c9 + 94 + "" + "" + "" + 1f777486cbacb84834939cf4312ba37f; + 1d26d0c6eb14ad568f86edd1 + "" + dc + "" + "" + ea4ee101b3dfc447826294eb9e188f93; + 9268eeee533285a6ed810c9b + "" + "" + 68 + 32 + 36ad1e9dd22bc536eaf6e1bf4148b92c; + 9daaa9060d2d4b6003062365 + b0a54364c76c160f11896c4794846ecf + a14a7130c9f137120634c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085406a61 + 36512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e6057acc87638f50804 + a2b79ebe3a643e16a26496a833169c430350296feff84ab5e97a837f27c1cebf042c077d8ea23697c1101fcd3880025e + 3e081ad4715f6b2ccf59ac6cbee3ecbf; + 6733d9ff61cdbda3b3e98787 + 31ebfedd4705e505da1435dceaa7b1 + cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2fc5fa450 + 727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b9 + e32192ca15a8b60348fbcad6bed31fec7d8930fb015efea33f827a691a245be1b056f237da85e63dd7f6948a583c5040b24eb76747 + c69cdf6b68ff0b95fd49073f69b24673; + 3bf4f2aad2605faee2b03fb648e27fff63102758 + "" + "" + "" + "" + 8197dfbcc4259667affb2610283f7cb5; + fe2b69ac26afa3349829b94586306fed54154f8f + 28 + "" + "" + "" + 4365d2d730280b57ebdd628d574db279; + 523c03d4de1600157846b710ee72807a2219bfb4 + "" + 74 + "" + "" + 90f8bb6ae36b77e86acd862d626e3e8b; + fd71d891f24bb65d1563259f9eb53b571ea629c5 + "" + "" + 4d + 4d + e0c975ce580afac6215a31f89ed849f5; + 57dd2d42f70800df9fcbaca48b77dba189196d1e + bba10b0467cb9fc2712a199e533fa915 + 6308cdec3f768281e040a9b9a222bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d + 95214ade49cb3b6f5fe8368131115c037ba323fe1dc8151784873f0eb5b647da6794c18b5337685a96ed65b9aca33852 + 68cd20e274b1dfc8045c4f1a2a862ae38adaf6f1b4d37a869e1ca4dce62cffab0e767e21b7980a7a6923a4e6036e261f + ab0fc228a30f96fc6af0af7ed3b2ca23; + 7ef19b09c063c46f88de9fd41e72d7b97e23e6ea + bdff3bcd211499268878dbf30f1dad + 89d4b9b12012e4713df46795630e7952d22bb02d7100b8b649377d20a8f083455b663e4ee1315f3c8f2aeb + fa921451dcd1af5813b70d30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d + 2d5f33737604edbff4256e1803d85fdf97b1d11755a7c54907279c926103ad6dfcd2a49bc8f09692af0225e58727302883110a1d9e + 66d2add5b20b0083fe707359e14b9a81; + 264a7f16cb16c2e8 + "" + "" + "" + "" + bfd46275d139ade04b23701a58f03996; + 15f422cdf0c8e303 + 08 + "" + "" + "" + 70b1aefbf33858867e95f8420409cc5c; + be3c31e6bc58c0b7 + "" + ca + "" + "" + 06ed7dfc19e244619a78291ebfe53e1e; + dcb658b970e47479 + "" + "" + a6 + b3 + 50a2cbdf827bdd413fc402b1bd4d3cad; + 84b5aefa69a4cd52 + 147ed12ca986981a874498ad0abef8bc + 4fcb70e27e98ef1f0446b42fb144d44b6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9 + eb1c8dd0b00951f284649016ed00456331854bc78bf43966eb0cfa9138ddc39908445608fe95e81c2533e31c9c1a9851 + 1717ca0fe9a9f844e7b875383fffb728907e4381ca81aaad7d07ae4559463a25e3eb4eddc2c1eb47ac009050404e125a + 54681d8a74c5240d91fedda335ba0106; + bc2810d858cbbc84 + 24d126b807e6daa089c3f9099c5ffb + 824173d7634c04226f30cbb7f0e4a973a8cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e3f + b90e1721b730374ffc9bc597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003cc0cae9ce021a5f1fa4ffa91544485f1a1258b2b + b49998808ffe0713f231dc44d5fefd7b091d037fa88a0b00fa7df49a9cb715fa11272ad859a1b6bcd40fa4a618d4b9694a98800fe1 + cfb2cf5bd57a0bd2e0b6e4766c85ee66; + 9b8f0911e32d65cc1770a18cbfe6effd1ff6778554acf1270485b203a3c1c4c967c0a458 + "" + "" + "" + "" + c182f7ff71663492c075606138691990; + cb948bdd409b687fa3a6827b480aa3a4c84cef64f6c9b53bf8f957f4b03cf43e89957f9a + 3e + "" + "" + "" + bfd6579cd96ad44cd5202593235be036; + 8128f8743d16687b7bb8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605 + "" + ac + "" + "" + b0aa4fd770b15ab6cf76338e9e4ffcc9; + 8451399587011677508a15dde524af3e2bee0646541a42c2ecccb44d65bad397abfaf529 + "" + "" + ee + 1e + d1aa1cfbf63991b5a87719a436f3bc15; + 41cf9a05c7efedef3401539c51d2a90bbf7f1bfc338ab0ef5746ea8fdcccd213e33f7e8a + 5718fd25014107c8e7d715a92add9589 + d1f5c054b2d983514605ec590294a319b9802068a9f891bc5ba5afabf8c3122d12d7ff3c41122d70d17d4569eaff59a3 + 32ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7abc8ad68daac90cfe22d + 6c1092bfaaba31b04c5ce196bd217368bbcb33fabbee09d16cc36d6047594e2f33f6241828d17230e69561355af84d2b + 9adaf12e17b54bb121e92f5262a03d46; + 2f1f2968cc42fa8b669ed3bb3542a9cf44bbc8c6254d980398bd94e66eb4563d405e5188 + 1e99027b8ab9aea3ccf860b0009740 + 763d96836c5f87b95460938de1288c69d80ea12ff4bb5f069b8a2e86041c1b9fc214e9ca2186ddf1f6a7a3 + aa7e740da967828e3604b35b15ffaa6c36800d9645563a308ba60076817523bd2abf1261b089d8f23a9c2835076a23faac2cdd6777 + 64f2ee469fb1577675427113e478b43ab8915dfc5a3370b0b55dadd51f1415083831183748bbbd393ee54171fa12a112addea5bffd + 4172000e1d04402689bffffdf46cabac; +} diff --git a/symm/t/noekeon b/symm/t/noekeon index f1e72964..4e6ade41 100644 --- a/symm/t/noekeon +++ b/symm/t/noekeon @@ -23,3 +23,42 @@ noekeon-cmac { 1f337f29549e6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10 c123e79e5caf935e4534444d32d814d3; } + +noekeon-eax { + e4bef260d7bcda163547d348b7551195 + "" + "" + "" + "" + 086d221cf45f48c8c1f0c176c227db42; + e77022907dd1dff7dac5c9941d26d0c6 + eb + "" + "" + "" + 5599da97576ed0f456791a6d00e17288; + 14ad568f86edd1dc9268eeee533285a6 + "" + ed + "" + "" + 40e6658bc9910a80906ad1337c633782; + 810c9b689daaa9060d2d4b6003062365 + "" + "" + b0 + f2 + 205c5f8a0dbeefddbead7141069de5d7; + a54364c76c160f11896c4794846ecfa1 + 4a7130c9f137120634c9519848a877ff + 77bf79192a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd8 + 8374d8cde8e160ad10997a21635c6d62c9269029df3e6057acc87638f508046733d9ff61cdbda3b3e9878731ebfedd47 + 3aae83e95da014773b3575f62054485064a2e2070a0449ab21a5dcdda2ff10d572e475a29d0bb4710a95c109641de055 + 8dc62b8af3aeb306e9469d238906612e; + 05e505da1435dceaa7b1cc49ae1d50c3 + 8201a894476b3f102b752eb9529533 + 966f27043eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215eb57bb3a4 + f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93bf4f2aad2605faee2b03fb648e27fff63102758fe + 5fe35fcbf55279bdca2295b483181ccff932771ccd59aa3e35b39b6564032af118547a9704fffe57c789a88b70c7eca6eaabea82b8 + 4953808f5678ba307676326facca87d2; +} diff --git a/symm/t/rc2 b/symm/t/rc2 index 642c5cb6..60b352ff 100644 --- a/symm/t/rc2 +++ b/symm/t/rc2 @@ -62,3 +62,150 @@ rc2-cmac { f4b03cf43e89957f9a3e8128f8743d16687b7b 9ffecd00a5ce33b6; } + +rc2-eax { + 60d7bcda163547d348b7551195e77022907dd1dff7dac5c9941d26d0c6eb14ad568f86edd1dc9268ee + "" + "" + "" + "" + 493b1fd04ede5d08; + ee533285a6ed810c9b689daaa9060d2d4b6003062365b0a54364c76c160f11896c4794846ecfa14a71 + 30 + "" + "" + "" + 21a99e853cf8d624; + c9f137120634c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085 + "" + 40 + "" + "" + c2a4952faeb51fe5; + 6a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e + "" + "" + 60 + d2 + bf5432b8192d764c; + 57acc87638f508046733d9ff61cdbda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c3 + 8201a894476b3f10 + 2b752eb9529533966f27043eb621b7f65b000961040ef2f9 + b2fc5fa450727a9b542cde52ebfda19d0ccc520f215eb57b + f9c3cc1576f674b14e65fbe890be777d513381d3fbfaf3b6 + 3b7bbf2f56718d0b; + b3a4f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93bf4f2aad2605f + aee2b03fb648e2 + 7fff63102758fe2b69ac26afa3349829b94586 + 306fed54154f8f28523c03d4de1600157846b710ee72807a2219bfb474 + 8d354144a9ae2bfb22f92a7c7bc3655d62b2b56d972a0b48fdc527118a + 168314d144ee4c2f; + fd71d891f24bb65d1563259f9eb53b571ea629c54d57dd2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f768281e040a9b9a222bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe836813111 + "" + "" + "" + "" + 8e3a0ea494b5dd15; + 5c037ba323fe1dc8151784873f0eb5b647da6794c18b5337685a96ed65b9aca338527ef19b09c063c46f88de9fd41e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89d4b9b12012e4713df46795630e7952d22bb02d7100b8b649377d20a8f083455b663e4ee1315f3c8f2aebfa921451dcd1af + 58 + "" + "" + "" + 3bb40705efd17087; + 13b70d30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed12ca986981a874498ad0abef8bc4fcb70e27e98ef1f0446b42fb144d4 + "" + 4b + "" + "" + 02dc7bc996b3d08a; + 6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb1c8dd0b00951f284649016ed00456331854bc78bf43966eb0cfa9138ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c04226f30cbb7f0e4a973 + "" + "" + a8 + 46 + 593604619e5f140b; + cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e3fb90e1721b730374ffc9bc597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003cc0cae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f0911e32d65cc1770a18cbfe6effd1ff6778554acf1270485b203a3c1c4c967c0a458cb948bdd + 409b687fa3a6827b + 480aa3a4c84cef64f6c9b53bf8f957f4b03cf43e89957f9a + 3e8128f8743d16687b7bb8deb9bd205b70e04c091d205cda + b775f9f9970f69be179df624ffa0a971fd60e1a77897730b + 1f3bee3056b77bef; + d9e9a79b1abf91b0851e5ca605ac8451399587011677508a15dde524af3e2bee0646541a42c2ecccb44d65bad397abfaf529ee41cf9a05c7efedef3401539c51d2a90bbf7f1bfc338ab0ef5746ea8fdcccd213e33f7e8a5718fd25014107c8e7d715a92add9589d1f5c054b2d983514605ec590294a319 + b9802068a9f891 + bc5ba5afabf8c3122d12d7ff3c41122d70d17d + 4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea272 + e4ad70206a32030a723a97c5fa7c051f0e47e4c419567c9f2465e6082b + b4e14cf29446000e; + 5cb2dac07ecde95759ac46fee6dda7abc8ad68 + "" + "" + "" + "" + e48136f1558ef9d4; + daac90cfe22d2f1f2968cc42fa8b669ed3bb35 + 42 + "" + "" + "" + 75a875a6cf6822dc; + a9cf44bbc8c6254d980398bd94e66eb4563d40 + "" + 5e + "" + "" + aff6510c3cfc9cf8; + 51881e99027b8ab9aea3ccf860b0009740763d + "" + "" + 96 + 73 + 0fbcddfb90453138; + 836c5f87b95460938de1288c69d80ea12ff4bb + 5f069b8a2e86041c + 1b9fc214e9ca2186ddf1f6a7a3aa7e740da967828e3604b3 + 5b15ffaa6c36800d9645563a308ba60076817523bd2abf12 + 8c0f4a82cdc742cf10c6bcd81f08fe54d44602b6b04d84cb + 6048b808054d2c5f; + 61b089d8f23a9c2835076a23faac2cdd67771c + c667a8331f0a17 + 0b66283e4f834a06148f302c3973accd56f6f2 + 4e33958b8c2e2352fd61e4fa8fec816ac861a8b33779f09e7a10fc02a8 + b136f77a805e9042723b12db98a1ab0c8af27b687ea3b81bd09cf15d20 + 94b18788b3964b32; + f48afa3080ee119a52a9a817e4f2b94b0820cab383a8cffeea7c48 + "" + "" + "" + "" + 441faa27cc4c5c56; + 6315799dc875fba578c8ec4837898a92142b5b0677da1ac273117b + 45 + "" + "" + "" + eae3c4243cea46f9; + bcfff5d5f8b6fde2893232a9f81d14517ffae475f6b94a43a67b3d + "" + 38 + "" + "" + 9a3430a79df38876; + 0d2f9aaafe2dd721c0095c8808847689211450ba8095ffab1eaadf + "" + "" + 66 + 2c + 0cb5f535e70f4099; + fd22ac1976063e113ab61f813e28a1397a7974a1d7f4220c785fe4 + 26a5a0e80f678d40 + 4147842941feeffdc2eb44dc8c0d5e8f444f7f4e0c893959 + b74dc23a7bb40e7e0013e5150686d2301b43a15a84e81d7f + 6a855a701998a62f385b9ec42102a67ef354925d18569dd8 + eac5dfe4f5cbfff8; + 5cedaa49e2414ebf47970e560475cff206877de69146acc3ab6cf8 + 556b7aa7769459 + 48d1b8834df2196c92ec1718dcdeee0d52d953 + 9726d2810391b3f9d10c39b07ae8f08ce7cee4758a386a9943e97dedfb + 9cf8b628ab6c3e8c69c289c3564027ff0de5e6bcecc38c05b8d1b7ec0a + fd274b8e3c469eb6; +} diff --git a/symm/t/rc5 b/symm/t/rc5 index 2c58adf9..78e1a3de 100644 --- a/symm/t/rc5 +++ b/symm/t/rc5 @@ -64,3 +64,150 @@ rc5-cmac { e9002926ad0284c738f4cb0f58a1e34c8b15ad 029a65f6ecedeaec; } + +rc5-eax { + 60d7bcda163547d348b7551195e77022907dd1dff7dac5c9941d26d0c6eb14ad568f86edd1dc9268eeee533285a6ed810c9b689daaa9060d2d4b6003062365b0a54364c76c160f11896c4794846ecfa14a7130c9f137120634c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e6057 + "" + "" + "" + "" + b6a3c65665d9698f; + acc87638f508046733d9ff61cdbda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93bf4f2aad2605faee2b03fb648e27fff63102758fe2b69ac26afa3349829b94586306fed5415 + 4f + "" + "" + "" + 28e0ed64beb3636e; + 8f28523c03d4de1600157846b710ee72807a2219bfb474fd71d891f24bb65d1563259f9eb53b571ea629c54d57dd2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f768281e040a9b9a222bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c037ba323fe1dc8151784873f0eb5b647da6794c18b5337685a + "" + 96 + "" + "" + 4e86273646b6d548; + ed65b9aca338527ef19b09c063c46f88de9fd41e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89d4b9b12012e4713df46795630e7952d22bb02d7100b8b649377d20a8f083455b663e4ee1315f3c8f2aebfa921451dcd1af5813b70d30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0b7cadcb658b9 + "" + "" + 70 + e2 + b61886a4345f760a; + e47479a684b5aefa69a4cd52147ed12ca986981a874498ad0abef8bc4fcb70e27e98ef1f0446b42fb144d44b6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb1c8dd0b00951f284649016ed00456331854bc78bf43966eb0cfa9138ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c04226f30cbb7f0e4a973a8cd190107 + 314717a77456f3ff + 669c732b58db8f48af65f7cc9e3fb90e1721b730374ffc9b + c597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003cc + c1032a72ac5e8845a7d27deae33795ccc3bf3caf3e3cb94d + ac40d28502442851; + 0cae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f0911e32d65cc1770a18cbfe6effd1ff6778554acf1270485b203a3c1c4c967c0a458cb948bdd409b687fa3a6827b480aa3a4c84cef64f6c9b53bf8f957f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605ac8451399587011677508a15dde524af3e2bee0646541a42c2ecccb44d65bad397abfaf529ee41cf + 9a05c7efedef34 + 01539c51d2a90bbf7f1bfc338ab0ef5746ea8f + dcccd213e33f7e8a5718fd25014107c8e7d715a92add9589d1f5c054b2 + bf3cf0b9900f40e42643c19226af6cff9d221051ab7a52e22bdb0343d0 + 19e314d1c9556ec7; + d983514605ec590294a319b9802068a9f891bc5ba5afabf8c3122d12d7ff3c41122d70d17d4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7abc8ad68daac90cfe22d2f1f2968cc42fa8b669ed3bb3542a9cf44bbc8c6254d980398bd94e66eb4563d405e51881e99027b8ab9aea3ccf860b0009740763d96836c5f87b95460938de1288c69d80ea12ff4bb5f069b8a2e86041c1b9fc214e9ca2186ddf1f6a7a3aa7e740da967828e3604b35b15ffaa6c36800d9645563a308ba60076817523bd2abf1261 + "" + "" + "" + "" + 3c01672989b90b3d; + b089d8f23a9c2835076a23faac2cdd67771cc667a8331f0a170b66283e4f834a06148f302c3973accd56f6f24e33958b8c2e2352fd61e4fa8fec816ac861a8b33779f09e7a10fc02a8f48afa3080ee119a52a9a817e4f2b94b0820cab383a8cffeea7c486315799dc875fba578c8ec4837898a92142b5b0677da1ac273117b45bcfff5d5f8b6fde2893232a9f81d14517ffae475f6b94a43a67b3d380d2f9aaafe2dd721c0095c8808847689211450ba8095ffab1eaadf66fd22ac1976063e113ab61f813e28a1397a7974a1d7f4220c785fe426a5a0e80f678d404147 + 84 + "" + "" + "" + ec812e10e0061171; + 2941feeffdc2eb44dc8c0d5e8f444f7f4e0c893959b74dc23a7bb40e7e0013e5150686d2301b43a15a84e81d7f5cedaa49e2414ebf47970e560475cff206877de69146acc3ab6cf8556b7aa776945948d1b8834df2196c92ec1718dcdeee0d52d9539726d2810391b3f9d10c39b07ae8f08ce7cee4758a386a9943e97dedfbe61e737882cd09c2b9a80f34c0fde11c2481b11fc76bfa4dbf710a9e544e0c536ca1e040f9ad5b04140d98edabe08485290a4d87d13b07398a1458c2c6b61dbdbc1cccada8c1a0a9aabb6c4e3c3554f8fb1ef61614c270295dfc0ca6551c + "" + a4 + "" + "" + f87f9705308d2757; + bdb75359f91cb9d921056b7de74fc9a9b37154ce6c0b396179d31f06a1dd5982cbc0d7cb23841da1ae8f4ae480cda98ad6cf2bacf6f9fd3f821330c43f3df6c2b3fac7cbcf96523d4723f91801325eb8553236651c96788d73d192ee53b3f3ebd66ddd98cedbe88e245de25b1593b70f8601562d90a9b59ed034a867642d25d54756fa5c47f16f64b837bb4926214211a1c696ba172010abb433922a22d9fd881519165eb9d85197a21cc34ac0d5ae7be8dbf98e4ffed2cf6b1372a5aa47b54fd9d70c70e117bf1cae71b3a56f0e7d839ea59cc783443d64f2ed6a29b9 + "" + "" + 68 + 2c + ecb3af42ad5aaf5c; + 56beca34fd6544bcf86b799e2a1681160ccf055f0fd3001da597a1406d465b7b1419ea51cf858f938f6daafbd656445a09898eaa96ffc3d1d2e31e4e34c94b8bfae64825ecd75a66d88eedb969ffe07669845ebb7a24c69f13d099f47166edf54538e88fbf433a7ff212085179e79771f6eee7283ab178ef2b800d7b969da05780ffc1ba78c70dda7a4ca2a25e771702fb1901ecfc8a959cb8e75079bb018ccc8c54f31b450e88f8e9002926ad0284c738f4cb0f58a1e34c8b15ad930c1b627235a2cb84241986c251f5b70be2367f047265264e0da72efe8995e6c932 + a17eab511eddb8e4 + ba463c663035a6ae8a7a899e4279d54d03f0e0f3e961dcfd + 40088d5be74088e4097efb0368c7e2f431ee6988cf2a0e9e + 097489eca92aa5642b549cfac254a0084e6392328b287f68 + 1e35efa371fa0754; + beb3de79c4f86c9e4fba61339d6d907eab7707ca48ff5ba1ae93d16225d469de5747bc1addf5748729720a320fe14fd29cfc59314fe2079c0a2535ded56112d6e3d33dcf7c71cd7d130323794e3da84a9df69703a9caf02d2a8f57ac71e554a6850d55882f8c7ae6994fc8528bd18c374fc43581d2f72a89584a2404a059f7f99c7241a0c879d6d4455b382a9ce757b3e7a1d07585ad9d7ea9c7c9cf54f3bc6d94238ab56d738e02abd651477cd726d6f3ebcd6fadeab50906642a7de6496247060e7be3632ed9bd94bb42f45a8733b2cd2df9d1d905cfdb29983050d6 + bcdb686a0c8970 + 31ad09a5b8fa687ec3bad8e18dc2ad361f1e22 + 6e78876cd35f86c639733c5cd84aed8aaebabb7e0f24edfd9710b7bca9 + faaae6078a435e40c355d6cb7522b57d1d2041d016be50c0499a94a4c9 + d37dacc2ee37665c; + 1b612ea37fc5cc09f7f62f66b423fcd2dec5de24d264f2c839839c1b06319f687dbc68d9f07fd4 + "" + "" + "" + "" + 8e0d69b365dcd5f0; + 1ccb4f8cde8de201ec2680332bbded4883deea0b58b54bdd13c17ef292b0ded3caeb5e57fd21df + 10 + "" + "" + "" + 70b4543f8437c930; + bc6186265ee6ea45907de6cb822fb2ef953aea358a03e0fce2e1b9511bd332c86e67f123377a8f + "" + 02 + "" + "" + 7b962a2f0a36c218; + 56b8dcc73ae1b3c6cd3f104e3cb24284cfed17811d64d492d39ea7496993a25b072945d83f923e + "" + "" + 66 + d3 + e3934e8cf3dd1e43; + b0a6689cf0969c003a8fca80e322a4b1bf050c1220450433efb6b6d8a2d820cf27a64b9d47f636 + 845dac557bb3e75f + 3a18fb8e173416867fcd0ee78ddd9236beec76d55ed58b10 + f91d07a037791ab96e83c4bf2fb5b205e592c172a5cbc194 + 1c11e3e723c447062953918da6c2935a8f736ba211e02110 + 26cf3b89bb9216cc; + 56c95c1bea6079f3867e52d663cb3884b2a0a8ff825df752423f3179bfeb89eca385f20ddce5f1 + f23564672e370f + fc37d400a31e8aac1d426ce10df73c5ee478b3 + b63d91024780e974a8a2a0e7a36f84ab1286b627e7d01b38a84a6de738 + 76d660c82fe87ec1fe0ae671550a17ecff0c9e771db2949c1b786f1cf2 + 740fccf37358c969; + 721ed80fd0d7f69fa658abb5a440d304128719b541a9451cead18e4c61d93d1f8fcc53574427767396322b3bf7d02cec05093696cec07591ada462271b1d1519eedde0df37a330fe8c22ebd777 + "" + "" + "" + "" + cfff0e086dd13bf8; + 05917b7e32ae88f45a34a8ba3037235e19a394be4d26ce47317d8087684456b4cfc5555e925e3e7b2ebc829b2d0505ea617b0ca9531bcdb96040d39040e632d562643ccb64286303040fcaf679 + e9 + "" + "" + "" + 1e93f551fac620d8; + 14eaddc05af8843ce6a427b99a5dc266de31c09165237eeefe4b58cc034b9f099f04678c2a9da898b39324cd3087a651014f6796f9c4881d89e127e62221e47e57badd678d490c2f320ff8fb1c + "" + 42 + "" + "" + ea6e9288b9febdb3; + 761bd439f3e96dc0ed1d5b2169912af1a4e2c533c52ba3e8c71c23a089e231480aa63c484fb34bd522397f102cb8ecf4f64e329884fe73be257a753b38200bc23f94a079bde2dd98d813655daf + "" + "" + a1 + 83 + 409170cbacd6adbb; + 5b85419d15c41a5153cce5d0e8c8702db2ba11927589678d4f7b8fcfad4818c411f15f452300903874f9a532ee46496ae753a2340af7b91f9632fc5ae71ae18b40de751ab6b6761ca16434a993 + 5e466e11c1cb072f + 32a59c313dba3db646ae909a096697d9a7b0556463ff1126 + ebc43263391424d02739d0787e804d8f1dccf6c897a8a484 + c9f82dea0b1b5fd479b0aeb37b717817455887a199312aa9 + 4e1d9e542a78d512; + 31324324041b5302ccd501b538bd03d5cb5c90d1fd3f7d2be187a787032c79ed900764ee4ce1d3fc042c084f7d8c0c48ad7d6f1eabd0fd1ec24a88f26734d5c8d92dbd873a8fe113090d401bea + 4d28ff49f10ff5 + 93adc258e091abd31b62dd1735158f98765970 + acc6602da063aae01a2a199d3a4f37a5f062d216d2053a83b5d3a0488a + a9dc22dc5d57626720b7c1260c63dae59cbad790ac527d5a26e7d943dd + 86f8915e2fdee1e3; +} diff --git a/symm/t/rijndael.local b/symm/t/rijndael.local index 053a0d48..5f68b95f 100644 --- a/symm/t/rijndael.local +++ b/symm/t/rijndael.local @@ -92,3 +92,216 @@ rijndael-cmac { 9c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0b7cadcb6 3a2d6cd3d65ba29059613d7e6b6e1278; } +rijndael-eax { + ## From Mihir Bellare, Phillip Rogaway, David Wagner, `The EAX Mode of + ## Operation (A Two-Pass Authenticated-Encryption Scheme Optimized for + ## Simplicity and Efficiency)'. + + 233952dee4d5ed5f9b9c6d6ff80ff478 + 62ec67f9c3a4a407fcb2a8c49031a8b3 + 6bfb914fd07eae6b + "" + "" + e037830e8389f27b025a2d6527e79d01; + 91945d3f4dcbee0bf45ef52255f095a4 + becaf043b0a23d843194ba972c66debd + fa3bfd4806eb53fa + f7fb + 19dd + 5c4c9331049d0bdab0277408f67967e5; + 01f74ad64077f2e704c0f60ada3dd523 + 70c3db4f0d26368400a10ed05d2bff5e + 234a3463c1264ac6 + 1a47cb4933 + d851d5bae0 + 3a59f238a23e39199dc9266626c40f80; + d07cf6cbb7f313bdde66b727afd3c5e8 + 8408dfff3c1a2b1292dc199e46b7d617 + 33cce2eabff5a79d + 481c9e39b1 + 632a9d131a + d4c168a4225d8e1ff755939974a7bede; + 35b6d0580005bbc12b0587124557d2c2 + fdb6b06676eedc5c61d74276e1f8e816 + aeb96eaebe2970e9 + 40d0c07da5e4 + 071dfe16c675 + cb0677e536f73afe6a14b74ee49844dd; + bd8e6e11475e60b268784c38c62feb22 + 6eac5c93072d8e8513f750935e46da1b + d4482d1ca78dce0f + 4de3b35c3fc039245bd1fb7d + 835bb4f15d743e350e728414 + abb8644fd6ccb86947c5e10590210a4f; + 7c77d6e813bed5ac98baa417477a2e7d + 1a8c98dcd73d38393b2bf1569deefc19 + 65d2017990d62528 + 8b0a79306c9ce7ed99dae4f87f8dd61636 + 02083e3979da014812f59f11d52630da30 + 137327d10649b0aa6e1c181db617d7f2; + 5fff20cafab119ca2fc73549e20f5b0d + dde59b97d722156d4d9aff2bc7559826 + 54b9f04e6a09189a + 1bda122bce8a8dbaf1877d962b8592dd2d56 + 2ec47b2c4954a489afc7ba4897edcdae8cc3 + 3b60450599bd02c96382902aef7f832a; + a4a4782bcffd3ec5e7ef6d8c34a56123 + b781fcf2f75fa5a8de97a9ca48e522ec + 899a175897561d7e + 6cf36720872b8513f6eab1a8a44438d5ef11 + 0de18fd0fdd91e7af19f1d8ee8733938b1e8 + e7f6d2231618102fdb7fe55ff1991700; + 8395fcf1e95bebd697bd010bc766aac3 + 22e7add93cfc6393c57ec0b3c17d6b44 + 126735fcc320d25a + ca40d7446e545ffaed3bd12a740a659ffbbb3ceab7 + cb8920f87a6c75cff39627b56e3ed197c552d295a7 + cfc46afc253b4652b1af3795b124ab6e; + + ## Some local tests for additional edge cases, generated using the toy + ## implementation in Python. + 60d7bcda163547d348b7551195e77022 + "" + "" + "" + "" + fc65784451ea97468ec025e17a709456; + 907dd1dff7dac5c9941d26d0c6eb14ad + 56 + "" + "" + "" + d8da3364e510165ed5afd2aab762f5d2; + 8f86edd1dc9268eeee533285a6ed810c + "" + 9b + "" + "" + 715b06133d886f3b8fb8fdfcadd0fa5c; + 689daaa9060d2d4b6003062365b0a543 + "" + "" + 64 + 69 + 16c192d8633a39465ce18da2ce132233; + c76c160f11896c4794846ecfa14a7130 + c9f137120634c9519848a877ff77bf79 + 192a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8 + cde8e160ad10997a21635c6d62c9269029df3e6057acc87638f508046733d9ff61cdbda3b3e9878731ebfedd4705e505 + 963801ede08bd2b86a3c33cf18c27d98c7c22f14c08621651e6094e72bcbd4bbf38f5e20814d465daa9c5929b9f59375 + 180ad55fa758703dd6a4e345956705e5; + da1435dceaa7b1cc49ae1d50c38201a8 + 94476b3f102b752eb9529533966f27 + 043eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3ebbb + b18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93bf4f2aad2605faee2b03fb648e27fff63102758fe2b69ac + 448792431ef5eb64efcfb2e6a9bb454d7ef09598ca4bc057d9cba969328ad75c05b7da7012e5ff1826dc3c981072fc9dce719cfffa + aeaa46b633b5c3ba7db2e404af2eb9a8; + 26afa3349829b94586306fed54154f8f28523c03 + "" + "" + "" + "" + d0a749a3ae472501971c7521066a5c14; + d4de1600157846b710ee72807a2219bfb474fd71 + d8 + "" + "" + "" + 5998cfaef8d97abd4c8017aba424a845; + 91f24bb65d1563259f9eb53b571ea629c54d57dd + "" + 2d + "" + "" + 7ecfd7cde12120a79d65622bd02993f8; + 42f70800df9fcbaca48b77dba189196d1ebba10b + "" + "" + 04 + 46 + b4b2f22374e5416565ea5da09bd65726; + 67cb9fc2712a199e533fa9156308cdec3f768281 + e040a9b9a222bd689aef66f5306ceb0c + 6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c037ba323fe1dc81517 + 84873f0eb5b647da6794c18b5337685a96ed65b9aca338527ef19b09c063c46f88de9fd41e72d7b97e23e6eabdff3bcd + 78ebdb6a281df84204a58c3071a81ee62c604c4ff408d02ec9401bd284beba033e438279a8cf450bccc58ddb0480b0b1 + 8f3edaf96c1c577c99d506fa9bdd342c; + 211499268878dbf30f1dad89d4b9b12012e4713d + f46795630e7952d22bb02d7100b8b6 + 49377d20a8f083455b663e4ee1315f3c8f2aebfa921451dcd1af5813b70d30ce2f1fef6ef315d079839180 + 5da08da3aefc5f8584b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0 + b81e04dfef276af4992a4daacad70a724bd2bc5f857d739b82781dab188f6c172f1dc3390ab9226f6a286bf89e3fd198ee3e781db4 + 1096e8cbf9132840e22c4e9618a981c2; + b7cadcb658b970e47479a684b5aefa69a4cd52147ed12ca986981a87 + "" + "" + "" + "" + 8517441bde0b33302a5d73d756bbaea3; + 4498ad0abef8bc4fcb70e27e98ef1f0446b42fb144d44b6d00f06dc1 + 88 + "" + "" + "" + 2703e5e0acbf6d762e635e66e599c7e7; + d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb1c + "" + 8d + "" + "" + 21ba7e9152f7a188a570a435a9118dd7; + d0b00951f284649016ed00456331854bc78bf43966eb0cfa9138ddc3 + "" + "" + 99 + 8f + 19edae1a9f72c3ec1a95456a7602fbea; + 08445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b8 + 07e6daa089c3f9099c5ffb824173d763 + 4c04226f30cbb7f0e4a973a8cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e3fb90e1721b730374ffc9b + c597f56ccbb2f294b38766fc69f6a9f2c0945ffd505003cc0cae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f0911e3 + 7da2cbb1dbb96d57e6eae7f7463cdaf220f06e96bcce1303ef6c987de22fa64d62c89f8bef1676b6c9447b03575fce9a + 83e41c3c033397193406be50be532022; + 2d65cc1770a18cbfe6effd1ff6778554acf1270485b203a3c1c4c967 + c0a458cb948bdd409b687fa3a6827b + 480aa3a4c84cef64f6c9b53bf8f957f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd205b70e04c + 091d205cdad9e9a79b1abf91b0851e5ca605ac8451399587011677508a15dde524af3e2bee0646541a42c2ecccb44d65bad397abfa + 5c26f8ce44729fef7b23d7a08a6f770499d3efd779ec6975b549f418abdffc8a1fe5c279e41e3815b8667e96a4ad39aeef24bee42f + cd68c88ece3bead81778b31e8dbe34db; + f529ee41cf9a05c7efedef34 + "" + "" + "" + "" + 9fa09ea950f21cf235e494490111462f; + 01539c51d2a90bbf7f1bfc33 + 8a + "" + "" + "" + b694f1a079840c1a5306fa86a0d4bba3; + b0ef5746ea8fdcccd213e33f + "" + 7e + "" + "" + 91c2e974c399c84bdff77b962441e1f3; + 8a5718fd25014107c8e7d715 + "" + "" + a9 + 14 + 279ad0e41ab70a6751f9fbd01030784e; + 2add9589d1f5c054b2d98351 + 4605ec590294a319b9802068a9f891bc + 5ba5afabf8c3122d12d7ff3c41122d70d17d4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725c + b2dac07ecde95759ac46fee6dda7abc8ad68daac90cfe22d2f1f2968cc42fa8b669ed3bb3542a9cf44bbc8c6254d9803 + cb3a052da8d3fc8c6e40de726ef40596a871d596df7b7c33b11467ba4ab39210df119a6e202267b44f86db3b4074c886 + 4ea05695bbf7f261c4e76415e3642945; + 98bd94e66eb4563d405e5188 + 1e99027b8ab9aea3ccf860b0009740 + 763d96836c5f87b95460938de1288c69d80ea12ff4bb5f069b8a2e86041c1b9fc214e9ca2186ddf1f6a7a3 + aa7e740da967828e3604b35b15ffaa6c36800d9645563a308ba60076817523bd2abf1261b089d8f23a9c2835076a23faac2cdd6777 + 03f7e555335edc0f776c210da68ddceda30e7b6d11f62aab60a17f443e6000c31ca8927b28791f8b5dcff245c82b63ebca8cdbeb9a + a860ca21635e5d2c1fa19d96a4c394fa; +} diff --git a/symm/t/rijndael192 b/symm/t/rijndael192 index 1ace8b10..ebfb230e 100644 --- a/symm/t/rijndael192 +++ b/symm/t/rijndael192 @@ -2933,3 +2933,150 @@ rijndael192-cmac { 9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c04226f30cbb7f0e4a973a8cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e 3848a7fc35a38ec5c202692eb9cc03067f1e3a587996a2fe; } + +rijndael192-eax { + 60d7bcda163547d348b7551195e77022 + "" + "" + "" + "" + 4f06617fd2435935d07da73b3fa4147dac1325a119046009; + 907dd1dff7dac5c9941d26d0c6eb14ad + 56 + "" + "" + "" + 91538eab427977388accbffddc6478f21b5fecbc6c7cb90a; + 8f86edd1dc9268eeee533285a6ed810c + "" + 9b + "" + "" + e5c24c4b113407583e10b409e553d653a5a519cba5f6d500; + 689daaa9060d2d4b6003062365b0a543 + "" + "" + 64 + b2 + 04d4d6804877ab6f6b3fa8566da51a683626144b1f15b0c9; + c76c160f11896c4794846ecfa14a7130 + c9f137120634c9519848a877ff77bf79192a5b50ade5d9cd + 739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e6057acc87638f508046733d9ff + 61cdbda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde + 5ab0c81553820168ce731c21e2d27c369cee4e9e62ad20e90f838e1e625efa976022de1063b1eea5f4b80f436fa05ff63b8805ccffe979d6d3809360b85598694b0e56f834aa44d6 + 4808e60011165622ccfea271b2720944612f7ba9fdaeff2b; + 52ebfda19d0ccc520f215eb57bb3a4f3 + ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad + 54efc9a38378c5b93bf4f2aad2605faee2b03fb648e27fff63102758fe2b69ac26afa3349829b94586306fed54154f8f28523c03d4de1600157846b710ee72807a2219 + bfb474fd71d891f24bb65d1563259f9eb53b571ea629c54d57dd2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f768281e040a9b9a222bd689a + f741602c2f1d8e46421651f6022a8c5525619a3231ccc623aa9220867f029b7fb8ded5cf9ecd06524d68399fad71cff1f9e3ec8b384d0eaa143f69593400261ad9bcb746d9be5dd613118b6448 + bb31af3207c2cabea82345be05be7fdf5198225ca65e71ed; + ef66f5306ceb0c6b08ac8b0a22260c571b4a42bb + "" + "" + "" + "" + 9f2973f4e855065a8d48db995fb178a141518b2737ac40d3; + 8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5f + e8 + "" + "" + "" + 44295827bbc06d0fd366f80689343bff188759f2cd39683c; + 368131115c037ba323fe1dc8151784873f0eb5b6 + "" + 47 + "" + "" + bc4ca9743e53d5cc9fae593892c0ce36d6a7d08547cfe2ed; + da6794c18b5337685a96ed65b9aca338527ef19b + "" + "" + 09 + 7c + dec701d10c4fdb386ca3d6546339bc1f896eaf2ab62fcc63; + c063c46f88de9fd41e72d7b97e23e6eabdff3bcd + 211499268878dbf30f1dad89d4b9b12012e4713df4679563 + 0e7952d22bb02d7100b8b649377d20a8f083455b663e4ee1315f3c8f2aebfa921451dcd1af5813b70d30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5e617669c0f16e3 + 9815d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f422cdf0c8e30308be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed12ca986981a874498ad0abef8bc4fcb + 0d0020cb99818864e1a42510c9f02fa9d8e1b7eeece9e2a47aee82a256d573aa3b4fc5e71b7bb3c728e738eb84efe398a767378611a9c567ddd1f2d1dde0542273f61eb745d20483 + 2370d3c0afd70bc36b3bf48b066e6a669bb6421d7c96f5a3; + 70e27e98ef1f0446b42fb144d44b6d00f06dc188 + d472a784e0c6f21195a3b9f4ae985511265febd11c1647 + 20eef9eb1c8dd0b00951f284649016ed00456331854bc78bf43966eb0cfa9138ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6daa0 + 89c3f9099c5ffb824173d7634c04226f30cbb7f0e4a973a8cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e3fb90e1721b730374ffc9bc597f56ccbb2f294b38766fc69f6a9f2c0 + 8c2e22689dfa878356ce69e873da970dfdacb405aab70851448ceb62ba02cb110d425683508f8575dda4f95545df5db12e04bffcf5b81c5b83a4ba6e5dffa6421f513791b59152f2e102afefe2 + 3e1b8d85bd6ac24ef82725ef0240e33f237223e26aff80ee; + 945ffd505003cc0cae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f + "" + "" + "" + "" + 75e5558c9504d6207f55489f4884c98abb6e0beec7a95435; + 0911e32d65cc1770a18cbfe6effd1ff6778554acf1270485b203a3c1 + c4 + "" + "" + "" + e39471f2d0b80ffcb2dbd929c96ae456486b7d8b3f11876e; + c967c0a458cb948bdd409b687fa3a6827b480aa3a4c84cef64f6c9b5 + "" + 3b + "" + "" + 6b3580a5ea32ba95c99712d167ca737628592fea8e2e2b99; + f8f957f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd205b + "" + "" + 70 + 01 + 124d761a70529ba540c4a3fdc8f027dbb1795a730ad5e11a; + e04c091d205cdad9e9a79b1abf91b0851e5ca605ac84513995870116 + 77508a15dde524af3e2bee0646541a42c2ecccb44d65bad3 + 97abfaf529ee41cf9a05c7efedef3401539c51d2a90bbf7f1bfc338ab0ef5746ea8fdcccd213e33f7e8a5718fd25014107c8e7d715a92add9589d1f5c054b2d983514605ec590294 + a319b9802068a9f891bc5ba5afabf8c3122d12d7ff3c41122d70d17d4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7 + 9f006d1fa01a0740b164f5e4c14a110cf20206a44206cd847498c555a495fb07fbb62f35082ec3303cc08298c364656b41c741318162786b2fe494e6cde8b670e64ef492de01027f + 712accd8ada4c4492c6fa2357c801ea07cb16b55179e2a5d; + abc8ad68daac90cfe22d2f1f2968cc42fa8b669ed3bb3542a9cf44bb + c8c6254d980398bd94e66eb4563d405e51881e99027b8a + b9aea3ccf860b0009740763d96836c5f87b95460938de1288c69d80ea12ff4bb5f069b8a2e86041c1b9fc214e9ca2186ddf1f6a7a3aa7e740da967828e3604b35b15ff + aa6c36800d9645563a308ba60076817523bd2abf1261b089d8f23a9c2835076a23faac2cdd67771cc667a8331f0a170b66283e4f834a06148f302c3973accd56f6f24e33958b8c2e2352fd61e4 + 7a12401a5a74a3791b3fea7958393230536885a7761e3716e36c2b571bf9510dc268dd30a4faded0794addc797a0661b6d485a4ed2c50ecefd4932e615ab6cc4c9180bcd5491541475508f873d + 22a1b541c2b7a784bcaaf00680273feb1a93c187e601413a; + fa8fec816ac861a8b33779f0 + "" + "" + "" + "" + e78606fd15a8ba1222d2f85ece0d3a66618ad8308820fdc9; + 9e7a10fc02a8f48afa3080ee + 11 + "" + "" + "" + 2a1684ea67082c34418df0f0d2366cfc1080b493930feaec; + 9a52a9a817e4f2b94b0820ca + "" + b3 + "" + "" + 83c2f7ecef5d874db22c51272440484a8fcd0b3beb84761c; + 83a8cffeea7c486315799dc8 + "" + "" + 75 + 1c + 1d96631473b4223491a78b3e90f91223dff32d90811433d3; + fba578c8ec4837898a92142b + 5b0677da1ac273117b45bcfff5d5f8b6fde2893232a9f81d + 14517ffae475f6b94a43a67b3d380d2f9aaafe2dd721c0095c8808847689211450ba8095ffab1eaadf66fd22ac1976063e113ab61f813e28a1397a7974a1d7f4220c785fe426a5a0 + e80f678d404147842941feeffdc2eb44dc8c0d5e8f444f7f4e0c893959b74dc23a7bb40e7e0013e5150686d2301b43a15a84e81d7f5cedaa49e2414ebf47970e560475cff206877d + 7daf1f5c982d561f22d520d3a528bdc16ea98a48c641b6314b0cd5c6da05f6bc6f3519be0a2c81177e44de266afa4f62b72d9c2800c039115ab81b671d940e314f1edaabe7685aec + e7d163d20f75659b4b0fa2b150abfabd0e1a83a4d5903a20; + e69146acc3ab6cf8556b7aa7 + 76945948d1b8834df2196c92ec1718dcdeee0d52d95397 + 26d2810391b3f9d10c39b07ae8f08ce7cee4758a386a9943e97dedfbe61e737882cd09c2b9a80f34c0fde11c2481b11fc76bfa4dbf710a9e544e0c536ca1e040f9ad5b + 04140d98edabe08485290a4d87d13b07398a1458c2c6b61dbdbc1cccada8c1a0a9aabb6c4e3c3554f8fb1ef61614c270295dfc0ca6551ca4bdb75359f91cb9d921056b7de74fc9a9b37154ce6c + f2a5115aa965c209277a24b0c325ce806520f4725aba623a5edd757c9b8ae4da2f4e918ceb2ba756bea2b7e16ce28cd808151ff29ea78c662ddaf739313c5930e2859da808369301b81db91309 + 77613f8246951823e51a3370da0344a58531540bafeded71; +} diff --git a/symm/t/rijndael256 b/symm/t/rijndael256 index 5513fee7..3ad53165 100644 --- a/symm/t/rijndael256 +++ b/symm/t/rijndael256 @@ -2946,3 +2946,150 @@ rijndael256-cmac { 7b480aa3a4c84cef64f6c9b53bf8f957f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605ac8451399587011677508a15dde524af3e2bee0646541a42c2ecccb44d 3e8977f205b75e6fae2105cbb8cdb26f3e8057957ce69b9e6be62362bd225924; } + +rijndael256-eax { + 60d7bcda163547d348b7551195e77022 + "" + "" + "" + "" + 56ae717b581681545bef99f97673b07d76c5f29cb1fbb3db8b99d59c99ab042b; + 907dd1dff7dac5c9941d26d0c6eb14ad + 56 + "" + "" + "" + 1284871421d525f5fea4eab5cd3236ad719701f0ab7e0f5de835de37e89c8828; + 8f86edd1dc9268eeee533285a6ed810c + "" + 9b + "" + "" + de3475c1039364a38f98e4ec3c432edbe31bed2b4ae2c5bad8d3ba1ec6338ad7; + 689daaa9060d2d4b6003062365b0a543 + "" + "" + 64 + 8e + 9f58b74b0c8c4612ddd9fc1a0a2ade2f129882dee66e9c7943d55fe32cf0c7cc; + c76c160f11896c4794846ecfa14a7130 + c9f137120634c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f2954 + 9e6b0d27a4ba234085406a6136512061f7080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e6057acc87638f508046733d9ff61cdbda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c38201a8 + 94476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93bf4f2aad2605faee2 + a59e5bba670ccd7caaa3eeeb6f7e45093846a32546fa3523791b2f132404d9a86f0f35fe46232811cd5b654c9e275c6db7f79e530cde3ace91d7a637ac4cbde01e09560059afc2da7aba6c16c5dd412608263b33187e27bac08512b611bf3819 + 21088f614b6dc3f1ca5a6cc1dda35b59373dc77f9a4b91954ec75ab8ee1f3d4a; + b03fb648e27fff63102758fe2b69ac26 + afa3349829b94586306fed54154f8f28523c03d4de1600157846b710ee7280 + 7a2219bfb474fd71d891f24bb65d1563259f9eb53b571ea629c54d57dd2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f768281e040a9b9a222bd689aef66f5306ceb0c6b08ac8b + 0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c037ba323fe1dc8151784873f0eb5b647da6794c18b5337685a96ed65b9aca338527ef19b09c063c46f88de9fd41e72d7b97e23e6eabdff3bcd211499268878dbf30f + 7e11239c076c83d990ba728f083f5e6937e80b81d31b1e8bfc4dd1341e4023a3b403fbdfc112b81795038ef923c300ed1c7a49399f873632ab1d48991e4484e3ed7ecbae505e69dea28e8bcb34d19a4c825d17ae6b3000d69c7729c66a4d75232e392573c4 + 37ccc36ae5a0cfb968bc686d6c61844a13d059ade69efb70bffcc7f4527e7db7; + 1dad89d4b9b12012e4713df46795630e7952d22b + "" + "" + "" + "" + 2a04e16b231801a616818eb325a3b6b4455ad7f0feb221fc9cf7ee7ae1f77975; + b02d7100b8b649377d20a8f083455b663e4ee131 + 5f + "" + "" + "" + c60fd57a9134b835c1a6ff8feb240db21bbba1f499562eda9487ba0046bcdadd; + 3c8f2aebfa921451dcd1af5813b70d30ce2f1fef + "" + 6e + "" + "" + 1c74926dd4c104bb6b4547117904d442e2f3a5f26fe303f2777d83043f70f6c6; + f315d0798391805da08da3aefc5f8584b7c5e617 + "" + "" + 66 + 4f + 4aeae19b9dcd25ad5b8bdfc749075ee42ad0352e7d335e6ef8c1b4d120eae1d2; + 9c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb + 16c2e815f422cdf0c8e30308be3c31e6bc58c0b7cadcb658b970e47479a684b5 + aefa69a4cd52147ed12ca986981a874498ad0abef8bc4fcb70e27e98ef1f0446b42fb144d44b6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb1c8dd0b00951f284649016ed00456331854bc78bf43966eb0c + fa9138ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb824173d7634c04226f30cbb7f0e4a973a8cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e3fb90e1721b730374f + 484516291ddd8425984d5b20f7951606f6992d02d8c39b044d86ebffbda479500671ec82f8c95889aae76eaf968a38aadba8c8ad820f319a72a6c3ca67d62df2fa069092c12337a22ca4be8438d851ee7ceb4cc6479af0a0cb8b5d6ab3a3c33c + 7fcc60c87daa5c131c20ef01161149e738b313743c0165fe272fffa6b8e04be1; + fc9bc597f56ccbb2f294b38766fc69f6a9f2c094 + 5ffd505003cc0cae9ce021a5f1fa4ffa91544485f1a1258b2b9b8f0911e32d + 65cc1770a18cbfe6effd1ff6778554acf1270485b203a3c1c4c967c0a458cb948bdd409b687fa3a6827b480aa3a4c84cef64f6c9b53bf8f957f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd205b70e04c091d205cdad9 + e9a79b1abf91b0851e5ca605ac8451399587011677508a15dde524af3e2bee0646541a42c2ecccb44d65bad397abfaf529ee41cf9a05c7efedef3401539c51d2a90bbf7f1bfc338ab0ef5746ea8fdcccd213e33f7e8a5718fd25014107c8e7d715a92add95 + 80366f86356bf3c47346f4ed75e7d21bdc49ccc63b9e606e3b322c53cc173537b7c43254b80bd6c044e2b778eddb8ec32d126c5cdf51c6e3bd13c5f48f8cf1e7596ee01b4ed1d5484ec4373aab252d08f61b8cb40c7ce46b561918f78ae0cdebe8159e900a + 8210e8551e214b45eb7e34f359022505753cf6a60dae9a31c4baf9d44abd7f87; + 89d1f5c054b2d983514605ec590294a319b9802068a9f891bc5ba5af + "" + "" + "" + "" + fd2fb424608049e61223ddd23da663c101854f3787a5bf134ebc623070c80e88; + abf8c3122d12d7ff3c41122d70d17d4569eaff59a332ba58d5d5589b + fe + "" + "" + "" + bd15c0ac8e80c6804cb853a059119ba0beec66a6935ffb590c4c6aa53abf9b89; + 079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6 + "" + dd + "" + "" + 8828d3a99b3ab60db2a397ddd9f0a0191aebe0e6a0d6f4020f3a281fc67765ec; + a7abc8ad68daac90cfe22d2f1f2968cc42fa8b669ed3bb3542a9cf44 + "" + "" + bb + a1 + 68445bb171a21e07feef9aad62a8069f645b621974ac7260589c4b5a5a309c3c; + c8c6254d980398bd94e66eb4563d405e51881e99027b8ab9aea3ccf8 + 60b0009740763d96836c5f87b95460938de1288c69d80ea12ff4bb5f069b8a2e + 86041c1b9fc214e9ca2186ddf1f6a7a3aa7e740da967828e3604b35b15ffaa6c36800d9645563a308ba60076817523bd2abf1261b089d8f23a9c2835076a23faac2cdd67771cc667a8331f0a170b66283e4f834a06148f302c3973accd56f6f2 + 4e33958b8c2e2352fd61e4fa8fec816ac861a8b33779f09e7a10fc02a8f48afa3080ee119a52a9a817e4f2b94b0820cab383a8cffeea7c486315799dc875fba578c8ec4837898a92142b5b0677da1ac273117b45bcfff5d5f8b6fde2893232a9 + 8f3a1855096bbe241f41b1084e58348e129ae4256d8b73414c3bf9eef729acc2f8a5a6f74ed553bc315b0817f0ab372ac20a58c13dd4e7610f8a090eec8f83189aa3341b36b90254c6893f9b58d3e611b7de06d764f8db43c34ba917809ba2be + c8832fe8c57e993797f82b5a17e027e875e72ea488f8baa729ed8d21db907479; + f81d14517ffae475f6b94a43a67b3d380d2f9aaafe2dd721c0095c88 + 08847689211450ba8095ffab1eaadf66fd22ac1976063e113ab61f813e28a1 + 397a7974a1d7f4220c785fe426a5a0e80f678d404147842941feeffdc2eb44dc8c0d5e8f444f7f4e0c893959b74dc23a7bb40e7e0013e5150686d2301b43a15a84e81d7f5cedaa49e2414ebf47970e560475cff206877de69146ac + c3ab6cf8556b7aa776945948d1b8834df2196c92ec1718dcdeee0d52d9539726d2810391b3f9d10c39b07ae8f08ce7cee4758a386a9943e97dedfbe61e737882cd09c2b9a80f34c0fde11c2481b11fc76bfa4dbf710a9e544e0c536ca1e040f9ad5b04140d + 74730c45d4e79313a2d4dc9fcaf3b1f00d7a79a35e3cb48139df5572d7d26384bc4547b53cfe81ae1e756a1fce648140acb0a11a9bff1b4a36e3937cfd01530279be056525885a7e33780f3df2404d44d866e2b968bb703ba65050343cce7ac7f37f17d3ca + 92dffe3138ec6f4100ff81315d0e0ed88a060a3542e6501979f34cd57c8d39fc; + 98edabe08485290a4d87d13b + "" + "" + "" + "" + 5d70d40b83d7893de0ee19cc043d24f37030e50f04e4670543a7d4bf20fce7fe; + 07398a1458c2c6b61dbdbc1c + cc + "" + "" + "" + 46eaab4431b6623fda169bb2106f6facf930e13c6484bf477e1d2f81e4134205; + ada8c1a0a9aabb6c4e3c3554 + "" + f8 + "" + "" + a9f67f2c4c00e287548b6518e7d04080973a60280a52dd2c239c63b2ddf3dc13; + fb1ef61614c270295dfc0ca6 + "" + "" + 55 + 3c + 9ddcbed5f12c814a6b3cd8c58e52bdc8de3a56e19a764633c48d9d1087b0aae5; + 1ca4bdb75359f91cb9d92105 + 6b7de74fc9a9b37154ce6c0b396179d31f06a1dd5982cbc0d7cb23841da1ae8f + 4ae480cda98ad6cf2bacf6f9fd3f821330c43f3df6c2b3fac7cbcf96523d4723f91801325eb8553236651c96788d73d192ee53b3f3ebd66ddd98cedbe88e245de25b1593b70f8601562d90a9b59ed034a867642d25d54756fa5c47f16f64b837 + bb4926214211a1c696ba172010abb433922a22d9fd881519165eb9d85197a21cc34ac0d5ae7be8dbf98e4ffed2cf6b1372a5aa47b54fd9d70c70e117bf1cae71b3a56f0e7d839ea59cc783443d64f2ed6a29b96856beca34fd6544bcf86b799e + 876d50aae158510c3d5ef05417d3a1532ec91e08ca4bb7e4abe971f7c37a8664b39483eb2754b99085dd6f33131571ac6132cb202eb43bf75cc87b0b8848ace90af17f93c4793b4cd454b84ccf6bc2c79cd9c5c4ffa670dab2db3933e0b5a79b + d6e3a30fea2cb62326007770a28f211f7bd318ca7b4b1e2cdbbffe8b4e5f4aaf; + 2a1681160ccf055f0fd3001d + a597a1406d465b7b1419ea51cf858f938f6daafbd656445a09898eaa96ffc3 + d1d2e31e4e34c94b8bfae64825ecd75a66d88eedb969ffe07669845ebb7a24c69f13d099f47166edf54538e88fbf433a7ff212085179e79771f6eee7283ab178ef2b800d7b969da05780ffc1ba78c70dda7a4ca2a25e771702fb19 + 01ecfc8a959cb8e75079bb018ccc8c54f31b450e88f8e9002926ad0284c738f4cb0f58a1e34c8b15ad930c1b627235a2cb84241986c251f5b70be2367f047265264e0da72efe8995e6c932a17eab511eddb8e4ba463c663035a6ae8a7a899e4279d54d03f0 + df7563a9736256abeeb7e528afd5868258e5eaa52b09d86eae63321459d7b39a681aad1b3ff8fb742a54f1a07d511162e9b282e50e24ffb8a3ad99b6a284f644cf82fc460fde1bbd338510f55e14ace30d831b9b7339d8129ce086330fad250c6091037555 + 22faf1c600ec3c2e7eaab84d8fc7b1a5fb63ef32d7161877da051ebfaed826bb; +} diff --git a/symm/t/safer b/symm/t/safer index 8d869af8..626e7faa 100644 --- a/symm/t/safer +++ b/symm/t/safer @@ -38,3 +38,78 @@ safer-cmac { 29df3e6057acc87638f508046733d9ff61cdbd fe61dbd63946d430; } + +safer-eax { + bef260d7bcda163547d348b7551195e7 + "" + "" + "" + "" + 75c1da0376977c83; + 7022907dd1dff7dac5c9941d26d0c6eb + 14 + "" + "" + "" + e8df12a3fceed9c1; + ad568f86edd1dc9268eeee533285a6ed + "" + 81 + "" + "" + 67fd181cddef533e; + 0c9b689daaa9060d2d4b6003062365b0 + "" + "" + a5 + 30 + b9ecf97c3093922d; + 4364c76c160f11896c4794846ecfa14a + 7130c9f137120634 + c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f + 29549e6b0d27a4ba234085406a6136512061f7080cc07df0 + fb58d0f5368ea912d10744647fe366bb418777601697e28c + 7ca11efe24763f77; + 591d8fa21f2dd88374d8cde8e160ad10 + 997a21635c6d62 + c9269029df3e6057acc87638f508046733d9ff + 61cdbda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c3 + 8f2eaca038f7cacc19b6cbd27ee094e6a78343fcead2b02356c41697ad + 216152ac7b8d453f; + 8201a894476b3f10 + "" + "" + "" + "" + b4d102bb91a06dbb; + 2b752eb952953396 + 6f + "" + "" + "" + ebaee4aba3e18cb1; + 27043eb621b7f65b + "" + 00 + "" + "" + 637a640605c9a7ff; + 0961040ef2f9b2fc + "" + "" + 5f + f8 + d5bfec2d60727408; + a450727a9b542cde + 52ebfda19d0ccc52 + 0f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090 + c54215abd6b3ad54efc9a38378c5b93bf4f2aad2605faee2 + 34969314934b38d9a462ef69cbbdb80c7cebd4e6361a5faa + 6f46339d37873473; + b03fb648e27fff63 + 102758fe2b69ac + 26afa3349829b94586306fed54154f8f28523c + 03d4de1600157846b710ee72807a2219bfb474fd71d891f24bb65d1563 + 27ebc64f0dc6fea2eb465c16ddcf0fb51567e3a14eeccdcf37be2ffb0a + a925cad73bd83f84; +} diff --git a/symm/t/safersk b/symm/t/safersk index 83233e10..b47d2253 100644 --- a/symm/t/safersk +++ b/symm/t/safersk @@ -26,3 +26,78 @@ safersk-cmac { 29df3e6057acc87638f508046733d9ff61cdbd d85e3e89ce01118c; } + +safersk-eax { + bef260d7bcda163547d348b7551195e7 + "" + "" + "" + "" + 9bc0cb5650ecbe0d; + 7022907dd1dff7dac5c9941d26d0c6eb + 14 + "" + "" + "" + 04655ac860f00c4c; + ad568f86edd1dc9268eeee533285a6ed + "" + 81 + "" + "" + 23de91600ff46611; + 0c9b689daaa9060d2d4b6003062365b0 + "" + "" + a5 + c2 + a47b7c287e2aaccb; + 4364c76c160f11896c4794846ecfa14a + 7130c9f137120634 + c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f + 29549e6b0d27a4ba234085406a6136512061f7080cc07df0 + d228821b771c225b34c32f1d8def6b1638a580259d14966c + c2d9f9bcacbf1796; + 591d8fa21f2dd88374d8cde8e160ad10 + 997a21635c6d62 + c9269029df3e6057acc87638f508046733d9ff + 61cdbda3b3e9878731ebfedd4705e505da1435dceaa7b1cc49ae1d50c3 + 56e9c63e94a3e304fb0204a14ddce527063e43cbb59e5f4cdc5ca4c9fd + 3c18c6748c8d3efb; + 8201a894476b3f10 + "" + "" + "" + "" + a30a7f2fdcfd304f; + 2b752eb952953396 + 6f + "" + "" + "" + a3921ada1effe4a9; + 27043eb621b7f65b + "" + 00 + "" + "" + b21c194c92a0e99a; + 0961040ef2f9b2fc + "" + "" + 5f + 9a + ec1dc651cd6f903d; + a450727a9b542cde + 52ebfda19d0ccc52 + 0f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090 + c54215abd6b3ad54efc9a38378c5b93bf4f2aad2605faee2 + 74b140592d02d6e569a0f917fd935c2c4ff50e612a765163 + 69c737214ba7d4ef; + b03fb648e27fff63 + 102758fe2b69ac + 26afa3349829b94586306fed54154f8f28523c + 03d4de1600157846b710ee72807a2219bfb474fd71d891f24bb65d1563 + bde1b3e1c19bb966ee531fa15ec929593e29aca538a004e1a98e6776f2 + ed2e0c47042a787f; +} diff --git a/symm/t/serpent.local b/symm/t/serpent.local index 60bc1a58..477caa91 100644 --- a/symm/t/serpent.local +++ b/symm/t/serpent.local @@ -50,3 +50,214 @@ serpent-cmac { 1e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89d4b9b12012e4713df46795630e7952d22bb02d 8ef0d030ddb7bd4c700e15efc563f5cf; } + +serpent-eax { + ## Taken from Secnet, with thanks to Ian Jackson. + + 233952dee4d5ed5f9b9c6d6ff80ff478 + 62ec67f9c3a4a407fcb2a8c49031a8b3 + 6bfb914fd07eae6b + "" + "" + 1271ec1e68330eb461a96d3a3a7a2707; + 91945d3f4dcbee0bf45ef52255f095a4 + becaf043b0a23d843194ba972c66debd + fa3bfd4806eb53fa + f7fb + 1c73 + 67d3db493a1f7b054ececa2a2cf37ee6; + 01f74ad64077f2e704c0f60ada3dd523 + 70c3db4f0d26368400a10ed05d2bff5e + 234a3463c1264ac6 + 1a47cb4933 + 2439712b59 + b13982351ba05b25bb2bd3b95df62d73; + d07cf6cbb7f313bdde66b727afd3c5e8 + 8408dfff3c1a2b1292dc199e46b7d617 + 33cce2eabff5a79d + 481c9e39b1 + f1d718884b + e94b29e143a264b54e283ca9e439c90d; + 35b6d0580005bbc12b0587124557d2c2 + fdb6b06676eedc5c61d74276e1f8e816 + aeb96eaebe2970e9 + 40d0c07da5e4 + 5936db85df31 + 199ba3556a5d5eff1964a6befea0d950; + bd8e6e11475e60b268784c38c62feb22 + 6eac5c93072d8e8513f750935e46da1b + d4482d1ca78dce0f + 4de3b35c3fc039245bd1fb7d + 7a3a7997ee349b57152cc43f + 723903a85b09d86456315ac0d9180724; + 7c77d6e813bed5ac98baa417477a2e7d + 1a8c98dcd73d38393b2bf1569deefc19 + 65d2017990d62528 + 8b0a79306c9ce7ed99dae4f87f8dd61636 + 73548ffaf45d2617eb25ad1dffa1842083 + 6d48394d5ef2cd2e0e30cdd2f4c52d96; + 5fff20cafab119ca2fc73549e20f5b0d + dde59b97d722156d4d9aff2bc7559826 + 54b9f04e6a09189a + 1bda122bce8a8dbaf1877d962b8592dd2d56 + e8bd1c6fe47df149a141ce813b0c1239542e + c4cbf7b3968388d631e6f4ffe86e14e7; + a4a4782bcffd3ec5e7ef6d8c34a56123 + b781fcf2f75fa5a8de97a9ca48e522ec + 899a175897561d7e + 6cf36720872b8513f6eab1a8a44438d5ef11 + e4a9d72847d437b85f10b7daa46f1e00e350 + 9af0b97961c39dfbb70170b6c4cadbc1; + 8395fcf1e95bebd697bd010bc766aac3 + 22e7add93cfc6393c57ec0b3c17d6b44 + 126735fcc320d25a + ca40d7446e545ffaed3bd12a740a659ffbbb3ceab7 + 83d69403eae9386b679daeaad2951465f8ddf9be1a + ffad1c5fef072f8b48bd58c07fee3d83; + + ## Locally-generated tests for edge-cases. + 60d7bcda163547d348b7551195 + "" + "" + "" + "" + 47f4f974dac8fbccb2d85c4dd030ecc2; + e77022907dd1dff7dac5c9941d + 26 + "" + "" + "" + fdd1a67df6ef4962c0e07c3bcb258fdb; + d0c6eb14ad568f86edd1dc9268 + "" + ee + "" + "" + dddced0e626e1a606ad6150f981231c4; + ee533285a6ed810c9b689daaa9 + "" + "" + 06 + 93 + 994b5c972bc7d85771220863405b62be; + 0d2d4b6003062365b0a54364c7 + 6c160f11896c4794846ecfa14a7130c9 + f137120634c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7 + 080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e6057acc87638f508046733d9ff61 + 82f5aab367d2f92bb06cdbdcf3b840fa03775f8473bc2c7923d06b0d264679c2bb8ad3a0b4008946198caa858ac3035b + 4be2dd26de2bb142d08d2e80ff7e1556; + cdbda3b3e9878731ebfedd4705 + e505da1435dceaa7b1cc49ae1d50c3 + 8201a894476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde + 52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93bf4f2aad260 + 4a2f0f21a4c240fcebbda1500c1c87193c1100ab9922b6c02b6200eb6c4c166ba715f09ba95ff7daa0a49a92139b1fb7785198c3cd + 7597b3928b3811ad02ba9c380fc053b7; + 5faee2b03fb648e27fff6310 + "" + "" + "" + "" + 0a85bbdf824c6fd51bb56934219a44bb; + 2758fe2b69ac26afa3349829 + b9 + "" + "" + "" + 8b3c4c5ef77b2b25cd78f8e7ee1a1eeb; + 4586306fed54154f8f28523c + "" + 03 + "" + "" + 9dd8b376a786caa020f631ec33e8adee; + d4de1600157846b710ee7280 + "" + "" + 7a + 9d + 66d221c6542adab014cde389a8375271; + 2219bfb474fd71d891f24bb6 + 5d1563259f9eb53b571ea629c54d57dd + 2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f768281e040a9b9a222 + bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe836813111 + d70c3fe1525edf6975dd3ec110f44d66ee38812bee278632cd476e9571d90ea3a4181e472841e699acbb613172b3c8d9 + cf949b9623f6027249246ff3914f4c9e; + 5c037ba323fe1dc815178487 + 3f0eb5b647da6794c18b5337685a96 + ed65b9aca338527ef19b09c063c46f88de9fd41e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89 + d4b9b12012e4713df46795630e7952d22bb02d7100b8b649377d20a8f083455b663e4ee1315f3c8f2aebfa921451dcd1af5813b70d + bbeb0d455e42b31743e6b1f62e7a8beb05b6579140f9523b441f1523fffd56799ea74a815f64cd65fe2d912c0ac88a42d668020ad4 + aa19b7bc58fb57f2cd072ed13f7a22d1; + 30ce2f1fef6ef315 + "" + "" + "" + "" + e071f4b5be472b5d27a62d3b59de4076; + d0798391805da08d + a3 + "" + "" + "" + 9700bb529c726f7f9383103afde5c072; + aefc5f8584b7c5e6 + "" + 17 + "" + "" + beddb35cd6ce26eeccd01fc49467f581; + 669c0f16e39815d4 + "" + "" + e9 + 89 + a6ea652052db22889858bba51b743f77; + cfce3ed1ecdf3d26 + 4a7f16cb16c2e815f422cdf0c8e30308 + be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed12ca986981a874498ad0abef8bc4fcb70e27e98 + ef1f0446b42fb144d44b6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb1c8dd0b009 + c343474bde0f534fb167d4f0f45dc029376218f83a54b3dd22eaf08ceb381357ae3c3f73e48d26775bbb3d09ea1300c2 + 9184a5120a75b987ebf1c111ee0f7fe0; + 51f284649016ed00 + 456331854bc78bf43966eb0cfa9138 + ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb82 + 4173d7634c04226f30cbb7f0e4a973a8cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e3fb90e1721b730374ffc9bc5 + 8a5f8d241fd8edabb3447134fced691a560ffc16eb35351f299055d61c65a9d016a8a2aecd321e2aaba5be088bc4e787d23279d3b9 + 2d94ce868ac29109422a40835e92df30; + 97f56ccbb2f294b38766fc69f6a9f2c094 + "" + "" + "" + "" + cc3b89f1e518665f325656d16078b115; + 5ffd505003cc0cae9ce021a5f1fa4ffa91 + 54 + "" + "" + "" + 77f9efcf277f9618606fd47f5233bb79; + 4485f1a1258b2b9b8f0911e32d65cc1770 + "" + a1 + "" + "" + 4d91889c474511f47711a00d22a37021; + 8cbfe6effd1ff6778554acf1270485b203 + "" + "" + a3 + f2 + db79e93136fbbcb2d167a14005e3e4f4; + c1c4c967c0a458cb948bdd409b687fa3a6 + 827b480aa3a4c84cef64f6c9b53bf8f9 + 57f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605ac + 8451399587011677508a15dde524af3e2bee0646541a42c2ecccb44d65bad397abfaf529ee41cf9a05c7efedef340153 + 242f387588ee5c723abeac99f710a02c29c5d9420475d5c81cd7840cdb9c965b2357c9fd6cf4ed18247daf5e5b4908d6 + 72aa25cd54aa0ed7bb78fdf9d491547e; + 9c51d2a90bbf7f1bfc338ab0ef5746ea8f + dcccd213e33f7e8a5718fd25014107 + c8e7d715a92add9589d1f5c054b2d983514605ec590294a319b9802068a9f891bc5ba5afabf8c3122d12d7 + ff3c41122d70d17d4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7ab + 2ea09fe497954fcc5ff649f0c72b229294018f6d69846e4d55b35fcf561d6d73e36fd253241af102f1a5beabca9f878898bebc3c38 + 018ad589b2a12c05238a52773fd66463; +} diff --git a/symm/t/skipjack b/symm/t/skipjack index a43c250f..6cd1da4f 100644 --- a/symm/t/skipjack +++ b/symm/t/skipjack @@ -114,3 +114,42 @@ skipjack-cmac { 65b0a54364c76c160f11896c4794846ecfa14a cffcc55881902725; } + +skipjack-eax { + e4bef260d7bcda163547 + "" + "" + "" + "" + b15f1791e4065ebd; + d348b7551195e7702290 + 7d + "" + "" + "" + 58aed98d9796d86e; + d1dff7dac5c9941d26d0 + "" + c6 + "" + "" + ed16d102bdd549c9; + eb14ad568f86edd1dc92 + "" + "" + 68 + 1c + c1a5644ab08ad1dc; + eeee533285a6ed810c9b + 689daaa9060d2d4b + 6003062365b0a54364c76c160f11896c4794846ecfa14a71 + 30c9f137120634c9519848a877ff77bf79192a5b50ade5d9 + b4bb56af916bc1a14e6a106346b9fbc1989b20d12275469f + 06a4958aa50a4260; + cd739a3d1f337f29549e + 6b0d27a4ba2340 + 85406a6136512061f7080cc07df0591d8fa21f + 2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e6057acc876 + 1e9afd31797d761c4f9ffbf0031a227872fa8b21de658b8fdb22514c48 + 44adbb6a2eae0a93; +} diff --git a/symm/t/square b/symm/t/square index 49cf0852..d639dd94 100644 --- a/symm/t/square +++ b/symm/t/square @@ -560,3 +560,114 @@ square-cmac { b94586306fed54154f8f28523c03d4de1600157846b710ee72807a2219bfb474fd71d891f24bb65d156325 a1fa99cf13347b5b803ccc6c2e183381; } + +square-eax { + f260d7bc + "" + "" + "" + "" + 66848361a1d85500e3efc4889f3c2bd1; + da163547 + d3 + "" + "" + "" + 3e14f9c0f9b208db9a52730d00525dc6; + 48b75511 + "" + 95 + "" + "" + 1b81e7698ff5e258ea2e8f75b7bcfd88; + e7702290 + "" + "" + 7d + d5 + c256dd01d1ee4db1387ef0f0b3d43b57; + d1dff7da + c5c9941d26d0c6eb14ad568f86edd1dc + 9268eeee533285a6ed810c9b689daaa9060d2d4b6003062365b0a54364c76c160f11896c4794846ecfa14a7130c9f137 + 120634c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7080c + cd9fbedf0befc513ec208493902b99f4e304654e0460d29920804d69dc150fa3e31d86a755ba930d0211fee9b7ca5f9f + f01b0b0089bf48fedc2c21556a1b644a; + c07df059 + 1d8fa21f2dd88374d8cde8e160ad10 + 997a21635c6d62c9269029df3e6057acc87638f508046733d9ff61cdbda3b3e9878731ebfedd4705e505da + 1435dceaa7b1cc49ae1d50c38201a894476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2fc5fa450727a9b54 + b88f48021b69e18d9457120fc11ebdd467c0b1119b5ab0bd16a5c3aa70e263d3ab841cbe6bba4fd02c94690dd143746294f825c26f + e0efd3bd220277de49de30272939c21c; + 2cde52ebfda19d0ccc520f21 + "" + "" + "" + "" + 8eac437bb3e523a1588a11e05db64b05; + 5eb57bb3a4f3ebbbb18ac6c9 + 5a + "" + "" + "" + 8950206e80699724eecfcaa54766d533; + 97a48030370c33d090c54215 + "" + ab + "" + "" + ddde409a326fe6d98ce631e1da7f54eb; + d6b3ad54efc9a38378c5b93b + "" + "" + f4 + d8 + 8288b113a8d26d40aba09cb3f2195dd8; + f2aad2605faee2b03fb648e2 + 7fff63102758fe2b69ac26afa3349829 + b94586306fed54154f8f28523c03d4de1600157846b710ee72807a2219bfb474fd71d891f24bb65d1563259f9eb53b57 + 1ea629c54d57dd2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f7682 + 4d1e0a695a91107ecb1d5247d28cfbf19237fc3f63e45f068d11dcbda21d83edcba5bdf9d3f06c2c8cab82fc41bf95dc + 530d31b751cdf63e4d3f69dbd3623c8a; + 81e040a9b9a222bd689aef66 + f5306ceb0c6b08ac8b0a22260c571b + 4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe8368131115c037ba323fe1dc8151784873f0eb5 + b647da6794c18b5337685a96ed65b9aca338527ef19b09c063c46f88de9fd41e72d7b97e23e6eabdff3bcd211499268878dbf30f1d + d547e342eb52d40545b00733505c306065b84193dc67ad9436f2acff5224cfe199885811c635803ec7d36a4756a55f97a7d79de113 + bed4ee2118bb4c7b7a12e34c60b7db7a; + ad89d4b9b12012e4 + "" + "" + "" + "" + c2044f9358ab48997b37cd48c3d71ff0; + 713df46795630e79 + 52 + "" + "" + "" + 7170fe71433b54c9891444470353f8ee; + d22bb02d7100b8b6 + "" + 49 + "" + "" + 070caac7af2fafb9acbc0dc299952b52; + 377d20a8f083455b + "" + "" + 66 + 91 + 1871fba93a1bd987dd232ffd84222d45; + 3e4ee1315f3c8f2a + ebfa921451dcd1af5813b70d30ce2f1f + ef6ef315d0798391805da08da3aefc5f8584b7c5e617669c0f16e39815d4e9cfce3ed1ecdf3d264a7f16cb16c2e815f4 + 22cdf0c8e30308be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed12ca986981a874498ad0abef8 + 34bea45625f646aa4fea5c08966df347998c5e91c3e243ddbae6ec95cbd9aef41e52e5bb71cc8d38470075e5f342d0a5 + b7d0633c6ed773da8c265c633cf8ebcb; + bc4fcb70e27e98ef + 1f0446b42fb144d44b6d00f06dc188 + d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb1c8dd0b00951f284649016ed00456331 + 854bc78bf43966eb0cfa9138ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5f + b11e564fe1caa81babd189007d9fdf983b4a086302d1eb98daec4f6c91849f873b84982b0a5c037b952355e0a0c916a3967e7ddb69 + b87b90233e12e003b8ffc0fa198d2269; +} diff --git a/symm/t/tea b/symm/t/tea index 62516fa1..35da6069 100644 --- a/symm/t/tea +++ b/symm/t/tea @@ -123,3 +123,150 @@ tea-cmac { ff63102758fe2b69ac26afa3349829b9458630 ac308d1e150a1c6e; } + +tea-eax { + 60d7bcda163547d348b7551195 + "" + "" + "" + "" + dd6dedcd5275f77b; + e77022907dd1dff7dac5c9941d + 26 + "" + "" + "" + 0601c82ec2fc3944; + d0c6eb14ad568f86edd1dc9268 + "" + ee + "" + "" + d7f75b8b18dabaab; + ee533285a6ed810c9b689daaa9 + "" + "" + 06 + 42 + 39a3b75cfe30c3e2; + 0d2d4b6003062365b0a54364c7 + 6c160f11896c4794 + 846ecfa14a7130c9f137120634c9519848a877ff77bf7919 + 2a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085 + 0f7263dd0709bb15fa04b8a0a27fe19b40e69596e2f7797d + f6a7ce18a023f8e6; + 406a6136512061f7080cc07df0 + 591d8fa21f2dd8 + 8374d8cde8e160ad10997a21635c6d62c92690 + 29df3e6057acc87638f508046733d9ff61cdbda3b3e9878731ebfedd47 + ddfb3fac295c9dd9307d5d1464f7b9f9d318b0e3e08fdd6f753b17e248 + b9850b3a65c973e7; + 05e505da1435dc + "" + "" + "" + "" + dc9b34fb8f76a62c; + eaa7b1cc49ae1d + 50 + "" + "" + "" + a3f9e0e94be8cc0e; + c38201a894476b + "" + 3f + "" + "" + a34f5355471f105e; + 102b752eb95295 + "" + "" + 33 + ad + 53d51c56bd3a3ee2; + 966f27043eb621 + b7f65b000961040e + f2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215e + b57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215 + bd62aa1bd2f58df364ecf889d4ede278c68a786cfa817416 + 69a5bc7134f4df07; + abd6b3ad54efc9 + a38378c5b93bf4 + f2aad2605faee2b03fb648e27fff63102758fe + 2b69ac26afa3349829b94586306fed54154f8f28523c03d4de16001578 + 345be4b0614ed2b6cee8f1d10f45f48bd6733ffab61b6f5a4fb978b66a + 6e7e6f6f73563d4e; + 46b710ee72807a2219bf + "" + "" + "" + "" + 6eedc1098c543339; + b474fd71d891f24bb65d + 15 + "" + "" + "" + fb16881264b9b3b2; + 63259f9eb53b571ea629 + "" + c5 + "" + "" + 753bcc1f76e8e1d2; + 4d57dd2d42f70800df9f + "" + "" + cb + 1b + 3eea24f4c849250a; + aca48b77dba189196d1e + bba10b0467cb9fc2 + 712a199e533fa9156308cdec3f768281e040a9b9a222bd68 + 9aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb23 + 78cdf18395582eae53580e5c7509bf60c8726dece28af741 + 5be9c10405f17081; + 3bfa6a5cfb0bad7d9521 + 4ade49cb3b6f5f + e8368131115c037ba323fe1dc8151784873f0e + b5b647da6794c18b5337685a96ed65b9aca338527ef19b09c063c46f88 + df834e65b1c814814d99f141cdbb8c2d201f47551689b9561f73df1a8d + 0b3460ba12e05a4a; + de9fd41e72d7b97e23 + "" + "" + "" + "" + 5532b9006b4c1a14; + e6eabdff3bcd211499 + 26 + "" + "" + "" + 9dc4ef03a759716f; + 8878dbf30f1dad89d4 + "" + b9 + "" + "" + abd0dd2ce24924b7; + b12012e4713df46795 + "" + "" + 63 + e0 + 5d2cc18653d26e6b; + 0e7952d22bb02d7100 + b8b649377d20a8f0 + 83455b663e4ee1315f3c8f2aebfa921451dcd1af5813b70d + 30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5 + a4321bcfe7f507eeced0ef16c59adb7010401f57d14a172a + bb947e016b25ce84; + e617669c0f16e39815 + d4e9cfce3ed1ec + df3d264a7f16cb16c2e815f422cdf0c8e30308 + be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed1 + 39f472084e8a3a053d250ae58c6a88e6313311f092a388c01ed590e3be + 62fab90c78f1e4d7; +} diff --git a/symm/t/twofish.local b/symm/t/twofish.local index 5aa904ab..db1047db 100644 --- a/symm/t/twofish.local +++ b/symm/t/twofish.local @@ -50,3 +50,150 @@ twofish-cmac { 1e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89d4b9b12012e4713df46795630e7952d22bb02d dabc6ab5c4f7051e8211bcafd27650f6; } + +twofish-eax { + 60d7bcda163547d348b7551195 + "" + "" + "" + "" + 9c340a7f586dfd6561333d865d3be637; + e77022907dd1dff7dac5c9941d + 26 + "" + "" + "" + b49707150b501a9aeb08849a8ce835c5; + d0c6eb14ad568f86edd1dc9268 + "" + ee + "" + "" + 7c390db5bff614ee888d1b5a9d58a08f; + ee533285a6ed810c9b689daaa9 + "" + "" + 06 + 19 + 747cff93ab194812482ac265aae10c05; + 0d2d4b6003062365b0a54364c7 + 6c160f11896c4794846ecfa14a7130c9 + f137120634c9519848a877ff77bf79192a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085406a6136512061f7 + 080cc07df0591d8fa21f2dd88374d8cde8e160ad10997a21635c6d62c9269029df3e6057acc87638f508046733d9ff61 + dd91fa89b463675215e5bf946e26d943bec9f16b85ab13386e59e241b8040179b9434123c3f18a91db1ca422e5ec4589 + 2516f3bef1bc5bc211b49bed94687265; + cdbda3b3e9878731ebfedd4705 + e505da1435dceaa7b1cc49ae1d50c3 + 8201a894476b3f102b752eb9529533966f27043eb621b7f65b000961040ef2f9b2fc5fa450727a9b542cde + 52ebfda19d0ccc520f215eb57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215abd6b3ad54efc9a38378c5b93bf4f2aad260 + edf0e0b4ca907432f7c994c4d185aa3db5d998ad1911852793c31f1e08c8a0facb5b743188745f1f1f0a3b5cb459a49b6568ade9d9 + a8755cc0ba6d7951c1e462f3d7488839; + 5faee2b03fb648e27fff6310 + "" + "" + "" + "" + fabb71671ec2e89032276be01704ef69; + 2758fe2b69ac26afa3349829 + b9 + "" + "" + "" + 560eafd0ed251ac82b143a85f180b657; + 4586306fed54154f8f28523c + "" + 03 + "" + "" + 94fafa14c9819062fb631fb20d784aed; + d4de1600157846b710ee7280 + "" + "" + 7a + a8 + db105495b660dbd22506ea66be1d09d5; + 2219bfb474fd71d891f24bb6 + 5d1563259f9eb53b571ea629c54d57dd + 2d42f70800df9fcbaca48b77dba189196d1ebba10b0467cb9fc2712a199e533fa9156308cdec3f768281e040a9b9a222 + bd689aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb233bfa6a5cfb0bad7d95214ade49cb3b6f5fe836813111 + 947c775e1a6deb3042c702a3600473796bebeb264ff0594b0352a85491239c812fa2f3c21d458e2b5b784625e5f8cc32 + 8e0728b45016d6178f32ee80773b72d0; + 5c037ba323fe1dc815178487 + 3f0eb5b647da6794c18b5337685a96 + ed65b9aca338527ef19b09c063c46f88de9fd41e72d7b97e23e6eabdff3bcd211499268878dbf30f1dad89 + d4b9b12012e4713df46795630e7952d22bb02d7100b8b649377d20a8f083455b663e4ee1315f3c8f2aebfa921451dcd1af5813b70d + 1d131416240ea96f731942579422e18acb633d0429a46d31b64ff5f24f8ee6bb05769731eaf0da2725da3204f04820baf228831c09 + e21621e777b6283f5fbb2095f4d9a668; + 30ce2f1fef6ef315 + "" + "" + "" + "" + 52512330b00f2450fdfcb97d554ac098; + d0798391805da08d + a3 + "" + "" + "" + 58800f1e6613f646fe7e562590c3de9f; + aefc5f8584b7c5e6 + "" + 17 + "" + "" + 72cb0d5710a6a99ba7618544108409ad; + 669c0f16e39815d4 + "" + "" + e9 + 69 + 05f8ecb88a66f4a0289e5e3d04bddbe7; + cfce3ed1ecdf3d26 + 4a7f16cb16c2e815f422cdf0c8e30308 + be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed12ca986981a874498ad0abef8bc4fcb70e27e98 + ef1f0446b42fb144d44b6d00f06dc188d472a784e0c6f21195a3b9f4ae985511265febd11c164720eef9eb1c8dd0b009 + 772117eeb7a3c0f1901d15bb4cd5aa2bbcc21c8900e9a590918c1278893bf93d6e10908d6aa0a3844de33ae47ef11fbf + 463ada14035a59434547a76404af4ee6; + 51f284649016ed00 + 456331854bc78bf43966eb0cfa9138 + ddc39908445608fe95e81c2533e31c9c1a9851bc2810d858cbbc8424d126b807e6daa089c3f9099c5ffb82 + 4173d7634c04226f30cbb7f0e4a973a8cd190107314717a77456f3ff669c732b58db8f48af65f7cc9e3fb90e1721b730374ffc9bc5 + 5f7a453a5988894d4c010d0c1d61c46e0fdac102b82d40e60fd88fa2a733048be1adc091040977c1ce28b608f3b47f541316a51382 + b3e874d11f8b935d338bd549a4d8158a; + 97f56ccbb2f294b38766fc69f6a9f2c094 + "" + "" + "" + "" + 522cec98b8703b39bdef4b7b71100e69; + 5ffd505003cc0cae9ce021a5f1fa4ffa91 + 54 + "" + "" + "" + 9696c681b07c07a545c546a9698822fb; + 4485f1a1258b2b9b8f0911e32d65cc1770 + "" + a1 + "" + "" + e99931b41ebf63d52cb833b03c3f6ea4; + 8cbfe6effd1ff6778554acf1270485b203 + "" + "" + a3 + 53 + c4f447d9deadfeb7916af9eb906f838d; + c1c4c967c0a458cb948bdd409b687fa3a6 + 827b480aa3a4c84cef64f6c9b53bf8f9 + 57f4b03cf43e89957f9a3e8128f8743d16687b7bb8deb9bd205b70e04c091d205cdad9e9a79b1abf91b0851e5ca605ac + 8451399587011677508a15dde524af3e2bee0646541a42c2ecccb44d65bad397abfaf529ee41cf9a05c7efedef340153 + ca3c5595f62889c4f242ac0da256bf103ca30908909139a4d43b0baa411a6fe47f8daf20b32bcba14f482f76b888265b + 041cf6ef9deec56c1bba923f276f8d75; + 9c51d2a90bbf7f1bfc338ab0ef5746ea8f + dcccd213e33f7e8a5718fd25014107 + c8e7d715a92add9589d1f5c054b2d983514605ec590294a319b9802068a9f891bc5ba5afabf8c3122d12d7 + ff3c41122d70d17d4569eaff59a332ba58d5d5589bfe079753ee1a957eb6d6699e6b7ea2725cb2dac07ecde95759ac46fee6dda7ab + 1cc781e5396ac8524f32f3a2e1dd087ce19381548225aa1d043499e04890a78ba1c21cad856ff355265a9760b6f81ba5a9b34d275f + bb1cd29c56a26e0a9ef3fc8341f8f663; +} diff --git a/symm/t/xtea b/symm/t/xtea index a8f27382..e08b496f 100644 --- a/symm/t/xtea +++ b/symm/t/xtea @@ -119,3 +119,150 @@ xtea-cmac { ff63102758fe2b69ac26afa3349829b9458630 295b9c45cd0a8bab; } + +xtea-eax { + 60d7bcda163547d348b7551195 + "" + "" + "" + "" + 5f1c8be04844ffdf; + e77022907dd1dff7dac5c9941d + 26 + "" + "" + "" + 3fec55f722a3295e; + d0c6eb14ad568f86edd1dc9268 + "" + ee + "" + "" + 41b22cdc7a09818c; + ee533285a6ed810c9b689daaa9 + "" + "" + 06 + 68 + 8b0dec6244e10dd9; + 0d2d4b6003062365b0a54364c7 + 6c160f11896c4794 + 846ecfa14a7130c9f137120634c9519848a877ff77bf7919 + 2a5b50ade5d9cd739a3d1f337f29549e6b0d27a4ba234085 + 4c3b648b0d6a0bf20eb496a17201e4fdd7581e1d34fe19f5 + 9576894304df1c06; + 406a6136512061f7080cc07df0 + 591d8fa21f2dd8 + 8374d8cde8e160ad10997a21635c6d62c92690 + 29df3e6057acc87638f508046733d9ff61cdbda3b3e9878731ebfedd47 + 495ac874eee71cda95fc4133cd8080514898385e542f44f56734ff86cf + 88db0b0c36963625; + 05e505da1435dc + "" + "" + "" + "" + b8d2cf3b4a2c82ed; + eaa7b1cc49ae1d + 50 + "" + "" + "" + ff304d08904cc45b; + c38201a894476b + "" + 3f + "" + "" + f13209350bfea66c; + 102b752eb95295 + "" + "" + 33 + 78 + 468ff217fd2da0e0; + 966f27043eb621 + b7f65b000961040e + f2f9b2fc5fa450727a9b542cde52ebfda19d0ccc520f215e + b57bb3a4f3ebbbb18ac6c95a97a48030370c33d090c54215 + c78a890e811a86978a2b944c7741ce0fc415aba17675e5be + 835bb97626f8a99e; + abd6b3ad54efc9 + a38378c5b93bf4 + f2aad2605faee2b03fb648e27fff63102758fe + 2b69ac26afa3349829b94586306fed54154f8f28523c03d4de16001578 + f8331f39c783a39406102bfdc1b324d0d4dabe5ec886474caef97209fd + e59ad9e764305aa4; + 46b710ee72807a2219bf + "" + "" + "" + "" + 603bc1df6ad3c9ef; + b474fd71d891f24bb65d + 15 + "" + "" + "" + bd337ef6bfba87bb; + 63259f9eb53b571ea629 + "" + c5 + "" + "" + 155833e773266034; + 4d57dd2d42f70800df9f + "" + "" + cb + 43 + d77a671a2285a75a; + aca48b77dba189196d1e + bba10b0467cb9fc2 + 712a199e533fa9156308cdec3f768281e040a9b9a222bd68 + 9aef66f5306ceb0c6b08ac8b0a22260c571b4a42bb8fdb23 + ba08278e81846ceb38153d309a3a01a57f415763091e31cd + 9ec9746c66fea592; + 3bfa6a5cfb0bad7d9521 + 4ade49cb3b6f5f + e8368131115c037ba323fe1dc8151784873f0e + b5b647da6794c18b5337685a96ed65b9aca338527ef19b09c063c46f88 + b73f49154f95bdba7d27565233290a8b987df10315aa519dd927f2c862 + 8ebd3aa28ee4a127; + de9fd41e72d7b97e23 + "" + "" + "" + "" + 6139eca5fd2a9750; + e6eabdff3bcd211499 + 26 + "" + "" + "" + 8acc9b1625d62fb2; + 8878dbf30f1dad89d4 + "" + b9 + "" + "" + 9730f31424a77b48; + b12012e4713df46795 + "" + "" + 63 + 33 + 0db62109955eeea5; + 0e7952d22bb02d7100 + b8b649377d20a8f0 + 83455b663e4ee1315f3c8f2aebfa921451dcd1af5813b70d + 30ce2f1fef6ef315d0798391805da08da3aefc5f8584b7c5 + 67acf23790a2997df84bf037c61118541471b963e076eb73 + b9d46f9d24d74df0; + e617669c0f16e39815 + d4e9cfce3ed1ec + df3d264a7f16cb16c2e815f422cdf0c8e30308 + be3c31e6bc58c0b7cadcb658b970e47479a684b5aefa69a4cd52147ed1 + 913b6bc765751a1b774bdd80b81b54a40e6b943acb8d922c5ea0b049d3 + 32a223a2cb999dba; +} diff --git a/utils/advmodes b/utils/advmodes index 96e5f5bf..3af744e2 100755 --- a/utils/advmodes +++ b/utils/advmodes @@ -103,6 +103,8 @@ def blocks0(x, w): if len(tl) == w: v.append(tl); tl = EMPTY return v, tl +def dummygen(bc): return [] + CUSTOM = {} ###-------------------------------------------------------------------------- @@ -266,6 +268,63 @@ def cmacgen(bc): (3*bc.blksz - 5,)] ###-------------------------------------------------------------------------- +### Counter mode. + +def ctr(E, m, c0): + blksz = E.__class__.blksz + y = C.WriteBuffer() + c = C.MP.loadb(c0) + while y.size < len(m): + y.put(E.encrypt(c.storeb(blksz))) + c += 1 + return C.ByteString(m) ^ C.ByteString(y)[:len(m)] + +###-------------------------------------------------------------------------- +### EAX. + +def eaxenc(E, n, h, m, tsz = None): + if VERBOSE: + print 'k = %s' % hex(k) + print 'n = %s' % hex(n) + print 'h = %s' % hex(h) + print 'm = %s' % hex(m) + dump_omac(E) + if tsz is None: tsz = E.__class__.blksz + c0 = omac(E, 0, n) + y = ctr(E, m, c0) + ht = omac(E, 1, h) + yt = omac(E, 2, y) + if VERBOSE: + print 'c0 = %s' % hex(c0) + print 'ht = %s' % hex(ht) + print 'yt = %s' % hex(yt) + return y, C.ByteString((c0 ^ ht ^ yt)[:tsz]) + +def eaxdec(E, n, h, y, t): + if VERBOSE: + print 'k = %s' % hex(k) + print 'n = %s' % hex(n) + print 'h = %s' % hex(h) + print 'y = %s' % hex(y) + print 't = %s' % hex(t) + dump_omac(E) + c0 = omac(E, 0, n) + m = ctr(E, y, c0) + ht = omac(E, 1, h) + yt = omac(E, 2, y) + if VERBOSE: + print 'c0 = %s' % hex(c0) + print 'ht = %s' % hex(ht) + print 'yt = %s' % hex(yt) + if t == (c0 ^ ht ^ yt)[:len(t)]: return m, + else: return None, + +def eaxgen(bc): + return [(0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1), + (bc.blksz, 3*bc.blksz, 3*bc.blksz), + (bc.blksz - 1, 3*bc.blksz - 5, 3*bc.blksz + 5)] + +###-------------------------------------------------------------------------- ### Main program. class struct (object): @@ -275,7 +334,9 @@ class struct (object): binarg = struct(mk = R.block, parse = C.bytes, show = safehex) intarg = struct(mk = lambda x: x, parse = int, show = None) -MODEMAP = { 'cmac': (cmacgen, [binarg], cmac) } +MODEMAP = { 'eax-enc': (eaxgen, 3*[binarg] + [intarg], eaxenc), + 'eax-dec': (dummygen, 4*[binarg], eaxdec), + 'cmac': (cmacgen, [binarg], cmac) } mode = argv[1] bc = None @@ -287,6 +348,7 @@ if bc is None: raise KeyError, argv[2] if len(argv) == 3: VERBOSE = False gen, argty, func = MODEMAP[mode] + if mode.endswith('-enc'): mode = mode[:-4] print '%s-%s {' % (bc.name, mode) for ksz in keylens(bc.keysz): for argvals in gen(bc): @@ -305,6 +367,8 @@ else: gen, argty, func = MODEMAP[mode] args = [t.parse(a) for t, a in izip(argty, argv[4:])] rets = func(bc(k), *args) - for r in rets: print hex(r) + for r in rets: + if r is None: print "X" + else: print hex(r) ###----- That's all, folks -------------------------------------------------- -- 2.11.0