X-Git-Url: https://git.distorted.org.uk/u/mdw/catacomb/blobdiff_plain/aa1082f28ddd05f3b946ca1a9c6bfaa17d18aca5..79ba130cb5776f994f6a3f0f87159d8cbc5ff129:/cfb-def.h diff --git a/cfb-def.h b/cfb-def.h new file mode 100644 index 0000000..85d95db --- /dev/null +++ b/cfb-def.h @@ -0,0 +1,499 @@ +/* -*-c-*- + * + * $Id: cfb-def.h,v 1.1 1999/12/10 23:16:39 mdw Exp $ + * + * Definitions for ciphertext feedback mode + * + * (c) 1999 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. + */ + +/*----- Revision history --------------------------------------------------* + * + * $Log: cfb-def.h,v $ + * Revision 1.1 1999/12/10 23:16:39 mdw + * Split mode macros into interface and implementation. + * + */ + +#ifndef CATACOMB_CFB_DEF_H +#define CATACOMB_CFB_DEF_H + +#ifdef __cplusplus + extern "C" { +#endif + +/*----- Header files ------------------------------------------------------*/ + +#include + +#include +#include + +#ifndef CATACOMB_BLKC_H +# include "blkc.h" +#endif + +#ifndef CATACOMB_GCIPHER_H +# include "gcipher.h" +#endif + +#ifndef CATACOMB_PARANOIA_H +# include "paranoia.h" +#endif + +/*----- Macros ------------------------------------------------------------*/ + +/* --- @CFB_DEF@ --- * + * + * Arguments: @PRE@, @pre@ = prefixes for the underlying block cipher + * + * Use: Creates an implementation for CFB mode. + */ + +#define CFB_DEF(PRE, pre) \ + \ +/* --- @pre_cfbgetiv@ --- * \ + * \ + * Arguments: @const pre_cfbctx *ctx@ = pointer to CFB context block \ + * @void *iv#@ = pointer to output data block \ + * \ + * Returns: --- \ + * \ + * Use: Reads the currently set IV. Reading and setting an IV \ + * is not transparent to the cipher. It will add a `step' \ + * which must be matched by a similar operation during \ + * decryption. \ + */ \ + \ +void pre##_cfbgetiv(const pre##_cfbctx *ctx, void *iv) \ +{ \ + octet *p = iv; \ + int off = ctx->off; \ + int rest = PRE##_BLKSZ - off; \ + memcpy(p, ctx->iv + off, rest); \ + memcpy(p + rest, ctx->iv, off); \ +} \ + \ +/* --- @pre_cfbsetiv@ --- * \ + * \ + * Arguments: @pre_cfbctx *ctx@ = pointer to CFB context block \ + * @cnost void *iv@ = pointer to IV to set \ + * \ + * Returns: --- \ + * \ + * Use: Sets the IV to use for subsequent encryption. \ + */ \ + \ +void pre##_cfbsetiv(pre##_cfbctx *ctx, const void *iv) \ +{ \ + uint32 niv[PRE##_BLKSZ / 4]; \ + BLKC_LOAD(PRE, niv, iv); \ + pre##_eblk(&ctx->ctx, niv, niv); \ + BLKC_STORE(PRE, ctx->iv, niv); \ + ctx->off = 0; \ +} \ + \ +/* --- @pre_cfbbdry@ --- * \ + * \ + * Arguments: @pre_cfbctx *ctx@ = pointer to CFB context block \ + * \ + * Returns: --- \ + * \ + * Use: Inserts a boundary during encryption. Successful \ + * decryption must place a similar boundary. \ + */ \ + \ +void pre##_cfbbdry(pre##_cfbctx *ctx) \ +{ \ + octet iv[PRE##_BLKSZ]; \ + pre##_cfbgetiv(ctx, iv); \ + pre##_cfbsetiv(ctx, iv); \ + BURN(iv); \ +} \ + \ +/* --- @pre_cfbsetkey@ --- * \ + * \ + * Arguments: @pre_cfbctx *ctx@ = pointer to CFB context block \ + * @const pre_ctx *k@ = pointer to cipher context \ + * \ + * Returns: --- \ + * \ + * Use: Sets the CFB context to use a different cipher key. \ + */ \ + \ +void pre##_cfbsetkey(pre##_cfbctx *ctx, const pre##_ctx *k) \ +{ \ + ctx->ctx = *k; \ +} \ + \ +/* --- @pre_cfbinit@ --- * \ + * \ + * Arguments: @pre_cfbctx *ctx@ = pointer to cipher context \ + * @const void *key@ = pointer to the key buffer \ + * @size_t sz@ = size of the key \ + * @const void *iv@ = pointer to initialization vector \ + * \ + * Returns: --- \ + * \ + * Use: Initializes a CFB context ready for use. You should \ + * ensure that the IV chosen is unique: reusing an IV will \ + * compromise the security of at least the first block \ + * encrypted. This is equivalent to calls to @pre_init@, \ + * @pre_cfbsetkey@ and @pre_cfbsetiv@. \ + */ \ + \ +void pre##_cfbinit(pre##_cfbctx *ctx, \ + const void *key, size_t sz, \ + const void *iv) \ +{ \ + static octet zero[PRE##_BLKSZ] = { 0 }; \ + pre##_init(&ctx->ctx, key, sz); \ + pre##_cfbsetiv(ctx, iv ? iv : zero); \ +} \ + \ +/* --- @pre_cfbencrypt@ --- * \ + * \ + * Arguments: @pre_cfbctx *ctx@ = pointer to CFB context block \ + * @const void *src@ = pointer to source data \ + * @void *dest@ = pointer to destination data \ + * @size_t sz@ = size of block to be encrypted \ + * \ + * Returns: --- \ + * \ + * Use: Encrypts a block with a block cipher in CFB mode. The \ + * input block may be arbitrary in size. CFB mode is not \ + * sensitive to block boundaries. \ + */ \ + \ +void pre##_cfbencrypt(pre##_cfbctx *ctx, \ + const void *src, void *dest, \ + size_t sz) \ +{ \ + const octet *s = src; \ + octet *d = dest; \ + int off = ctx->off; \ + \ + /* --- Empty blocks are trivial --- */ \ + \ + if (!sz) \ + return; \ + \ + /* --- If I can deal with the block from my buffer, do that --- */ \ + \ + if (sz < PRE##_BLKSZ - off) \ + goto small; \ + \ + /* --- Finish off what's left in my buffer --- */ \ + \ + while (off < PRE##_BLKSZ) { \ + register octet x = *s++; \ + *d++ = ctx->iv[off++] ^= x; \ + sz--; \ + } \ + \ + /* --- Main encryption loop --- */ \ + \ + { \ + uint32 iv[PRE##_BLKSZ / 4]; \ + BLKC_LOAD(PRE, iv, ctx->iv); \ + \ + for (;;) { \ + pre##_eblk(&ctx->ctx, iv, iv); \ + if (sz < PRE##_BLKSZ) \ + break; \ + BLKC_XLOAD(PRE, iv, s); \ + BLKC_STORE(PRE, d, iv); \ + s += PRE##_BLKSZ; \ + d += PRE##_BLKSZ; \ + sz -= PRE##_BLKSZ; \ + } \ + off = 0; \ + BLKC_STORE(PRE, ctx->iv, iv); \ + } \ + \ + /* --- Tidying up the tail end --- */ \ + \ + if (sz) { \ + small: \ + do { \ + register octet x = *s++; \ + *d++ = ctx->iv[off++] ^= x; \ + sz--; \ + } while (sz); \ + } \ + \ + /* --- Done --- */ \ + \ + ctx->off = off; \ + return; \ +} \ + \ +/* --- @pre_cfbencrypt@ --- * \ + * \ + * Arguments: @pre_cfbctx *ctx@ = pointer to CFB context block \ + * @const void *src@ = pointer to source data \ + * @void *dest@ = pointer to destination data \ + * @size_t sz@ = size of block to be encrypted \ + * \ + * Returns: --- \ + * \ + * Use: Decrypts a block with a block cipher in CFB mode. The \ + * input block may be arbitrary in size. CFB mode is not \ + * sensitive to block boundaries. \ + */ \ + \ +void pre##_cfbdecrypt(pre##_cfbctx *ctx, \ + const void *src, void *dest, \ + size_t sz) \ +{ \ + const octet *s = src; \ + octet *d = dest; \ + int off = ctx->off; \ + \ + /* --- Empty blocks are trivial --- */ \ + \ + if (!sz) \ + return; \ + \ + /* --- If I can deal with the block from my buffer, do that --- */ \ + \ + if (sz < PRE##_BLKSZ - off) \ + goto small; \ + \ + /* --- Finish off what's left in my buffer --- */ \ + \ + while (off < PRE##_BLKSZ) { \ + register octet x = *s++; \ + *d++ = ctx->iv[off] ^ x; \ + ctx->iv[off++] = x; \ + sz--; \ + } \ + \ + /* --- Main encryption loop --- */ \ + \ + { \ + uint32 iv[PRE##_BLKSZ / 4]; \ + BLKC_LOAD(PRE, iv, ctx->iv); \ + \ + for (;;) { \ + uint32 x[PRE##_BLKSZ / 4]; \ + pre##_eblk(&ctx->ctx, iv, iv); \ + if (sz < PRE##_BLKSZ) \ + break; \ + BLKC_LOAD(PRE, x, s); \ + BLKC_XSTORE(PRE, d, iv, x); \ + BLKC_MOVE(PRE, iv, x); \ + s += PRE##_BLKSZ; \ + d += PRE##_BLKSZ; \ + sz -= PRE##_BLKSZ; \ + } \ + off = 0; \ + BLKC_STORE(PRE, ctx->iv, iv); \ + } \ + \ + /* --- Tidying up the tail end --- */ \ + \ + if (sz) { \ + small: \ + do { \ + register octet x = *s++; \ + *d++ = ctx->iv[off] ^ x; \ + ctx->iv[off++] = x; \ + sz--; \ + } while (sz); \ + } \ + \ + /* --- Done --- */ \ + \ + ctx->off = off; \ + return; \ +} \ + \ +/* --- Generic cipher interface --- */ \ + \ +static const gcipher_ops gops; \ + \ +typedef struct gctx { \ + gcipher c; \ + pre##_cfbctx k; \ +} gctx; \ + \ +static gcipher *ginit(const void *k, size_t sz) \ +{ \ + gctx *g = CREATE(gctx); \ + g->c.ops = &gops; \ + pre##_cfbinit(&g->k, k, sz, 0); \ + return (&g->c); \ +} \ + \ +static void gencrypt(gcipher *c, const void *s, void *t, size_t sz) \ +{ \ + gctx *g = (gctx *)c; \ + pre##_cfbencrypt(&g->k, s, t, sz); \ +} \ + \ +static void gdecrypt(gcipher *c, const void *s, void *t, size_t sz) \ +{ \ + gctx *g = (gctx *)c; \ + pre##_cfbdecrypt(&g->k, s, t, sz); \ +} \ + \ +static void gdestroy(gcipher *c) \ +{ \ + gctx *g = (gctx *)c; \ + DESTROY(g); \ +} \ + \ +static void gsetiv(gcipher *c, const void *iv) \ +{ \ + gctx *g = (gctx *)c; \ + pre##_cfbsetiv(&g->k, iv); \ +} \ + \ +static void gbdry(gcipher *c) \ +{ \ + gctx *g = (gctx *)c; \ + pre##_cfbbdry(&g->k); \ +} \ + \ +static const gcipher_ops gops = { \ + &pre##_cfb.b, \ + gencrypt, gdecrypt, gdestroy, gsetiv, gbdry \ +}; \ + \ +const gccipher pre##_cfb = { \ + { #pre "-cfb", PRE##_KEYSZ, PRE##_BLKSZ }, \ + ginit \ +}; \ + \ +CFB_TEST(PRE, pre) + +/*----- Test rig ----------------------------------------------------------*/ + +#ifdef TEST_RIG + +#include + +#include "daftstory.h" + +/* --- @CFB_TEST@ --- * + * + * Arguments: @PRE@, @pre@ = prefixes for block cipher definitions + * + * Use: Standard test rig for CFB functions. + */ + +#define CFB_TEST(PRE, pre) \ + \ +/* --- Initial plaintext for the test --- */ \ + \ +static const octet text[] = TEXT; \ + \ +/* --- Key and IV to use --- */ \ + \ +static const octet key[] = KEY; \ +static const octet iv[] = IV; \ + \ +/* --- Buffers for encryption and decryption output --- */ \ + \ +static octet ct[sizeof(text)]; \ +static octet pt[sizeof(text)]; \ + \ +static void hexdump(const octet *p, size_t sz) \ +{ \ + const octet *q = p + sz; \ + for (sz = 0; p < q; p++, sz++) { \ + printf("%02x", *p); \ + if ((sz + 1) % PRE##_BLKSZ == 0) \ + putchar(':'); \ + } \ +} \ + \ +int main(void) \ +{ \ + size_t sz = 0, rest; \ + pre##_cfbctx ctx; \ + int status = 0; \ + int done = 0; \ + pre##_ctx k; \ + \ + size_t keysz = PRE##_KEYSZ ? \ + PRE##_KEYSZ : strlen((const char *)key); \ + \ + fputs(#pre "-cfb: ", stdout); \ + \ + pre##_init(&k, key, keysz); \ + pre##_cfbsetkey(&ctx, &k); \ + \ + while (sz <= sizeof(text)) { \ + rest = sizeof(text) - sz; \ + memcpy(ct, text, sizeof(text)); \ + pre##_cfbsetiv(&ctx, iv); \ + pre##_cfbencrypt(&ctx, ct, ct, sz); \ + pre##_cfbencrypt(&ctx, ct + sz, ct + sz, rest); \ + memcpy(pt, ct, sizeof(text)); \ + pre##_cfbsetiv(&ctx, iv); \ + pre##_cfbdecrypt(&ctx, pt, pt, rest); \ + pre##_cfbdecrypt(&ctx, pt + rest, pt + rest, sz); \ + if (memcmp(pt, text, sizeof(text)) == 0) { \ + done++; \ + if (sizeof(text) < 40 || done % 8 == 0) \ + fputc('.', stdout); \ + if (done % 480 == 0) \ + fputs("\n\t", stdout); \ + fflush(stdout); \ + } else { \ + printf("\nError (sz = %lu)\n", (unsigned long)sz); \ + status = 1; \ + printf("\tplaintext = "); hexdump(text, sz); \ + printf(", "); hexdump(text + sz, rest); \ + fputc('\n', stdout); \ + printf("\tciphertext = "); hexdump(ct, sz); \ + printf(", "); hexdump(ct + sz, rest); \ + fputc('\n', stdout); \ + printf("\trecovered text = "); hexdump(pt, sz); \ + printf(", "); hexdump(pt + sz, rest); \ + fputc('\n', stdout); \ + fputc('\n', stdout); \ + } \ + if (sz < 63) \ + sz++; \ + else \ + sz += 9; \ + } \ + \ + fputs(status ? " failed\n" : " ok\n", stdout); \ + return (status); \ +} + +#else +# define CFB_TEST(PRE, pre) +#endif + +/*----- That's all, folks -------------------------------------------------*/ + +#ifdef __cplusplus + } +#endif + +#endif