progs/perftest.c: Use from Glibc syscall numbers.

[catacomb] / symm / cfb-def.h

/* -*-c-*-
 *
 * 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.
 */

#ifndef CATACOMB_CFB_DEF_H
#define CATACOMB_CFB_DEF_H

#ifdef __cplusplus
  extern "C" {
#endif

/*----- Header files ------------------------------------------------------*/

#include <string.h>

#include <mLib/bits.h>
#include <mLib/sub.h>

#ifndef CATACOMB_ARENA_H
#  include "arena.h"
#endif

#ifndef CATACOMB_BLKC_H
#  include "blkc.h"
#endif

#ifndef CATACOMB_GCIPHER_H
#  include "gcipher.h"
#endif

#ifndef CATACOMB_PARANOIA_H
#  include "paranoia.h"
#endif

#ifndef CATACOMB_PARANOIA_H
#  include "paranoia.h"
#endif

#ifndef CATACOMB_RSVR_H
#  include "rsvr.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) CFB_DEFX(PRE, pre, #pre, #pre)

#define CFB_DEFX(PRE, pre, name, fname)					\
									\
/* --- @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;							\
  unsigned off = ctx->off;						\
  unsigned rest = PRE##_BLKSZ - off;					\
									\
  memcpy(p, ctx->b + off, rest);					\
  memcpy(p + rest, ctx->b, 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)			\
  { memcpy(ctx->b, iv, PRE##_BLKSZ); 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)					\
{									\
  uint32 t[PRE##_BLKSZ/4];						\
									\
  BLKC_LOAD(PRE, t, ctx->b);						\
  pre##_eblk(&ctx->ctx, t, t);						\
  BLKC_STORE(PRE, ctx->b, t);						\
  ctx->off = 0;								\
  BURN(t);								\
}									\
									\
/* --- @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; ctx->off = 0; }					\
									\
/* --- @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 const 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.				\
 */									\
									\
static const rsvr_policy pre##_cfbpolicy = { 0, PRE##_BLKSZ, PRE##_BLKSZ }; \
									\
void pre##_cfbencrypt(pre##_cfbctx *ctx,				\
		      const void *src, void *dest,			\
		      size_t sz)					\
{									\
  rsvr_plan plan;							\
  const octet *s = src;							\
  octet *d = dest, *p;							\
  uint32 t[PRE##_BLKSZ/4];						\
  octet y;								\
									\
  /* Construct a plan and prepare to follow through. */			\
  rsvr_mkplan(&plan, &pre##_cfbpolicy, ctx->off, sz);			\
  BLKC_LOAD(PRE, t, ctx->b);						\
									\
  /* Initial portion, fulfilled from the buffer.  If the chunk is small	\
   * enough, then this will be the only portion.  If the buffer is	\
   * currently empty, then we must prepare it.				\
   */									\
  if (plan.head) {							\
    if (!ctx->off) {							\
      pre##_eblk(&ctx->ctx, t, t);					\
      BLKC_STORE(PRE, ctx->b, t);					\
    }									\
    p = ctx->b + ctx->off; ctx->off += plan.head;			\
    if (s) while (plan.head--) { y = *s++ ^ *p; *p++ = y; if (d) *d++ = y; } \
    else if (d) { memcpy(d, p, plan.head); d += plan.head; }		\
    BLKC_LOAD(PRE, t, ctx->b);						\
  }									\
									\
  /* If the buffer is all used, then reset it ready for next time. */	\
  ctx->off -= plan.from_rsvr;						\
									\
  /* Handle multiple whole blocks. */					\
  if (!d) {								\
    if (!s) while (plan.from_input) {					\
      pre##_eblk(&ctx->ctx, t, t);					\
      plan.from_input -= PRE##_BLKSZ;					\
    } else while (plan.from_input) {					\
      pre##_eblk(&ctx->ctx, t, t);					\
      BLKC_XLOAD(PRE, t, s); s += PRE##_BLKSZ;				\
      plan.from_input -= PRE##_BLKSZ;					\
    }									\
  } else {								\
    if (!s) while (plan.from_input) {					\
      pre##_eblk(&ctx->ctx, t, t);					\
      BLKC_STORE(PRE, d, t); d += PRE##_BLKSZ;				\
      plan.from_input -= PRE##_BLKSZ;					\
    } else while (plan.from_input) {					\
      pre##_eblk(&ctx->ctx, t, t);					\
      BLKC_XLOAD(PRE, t, s); s += PRE##_BLKSZ;				\
      BLKC_STORE(PRE, d, t); d += PRE##_BLKSZ;				\
      plan.from_input -= PRE##_BLKSZ;					\
    }									\
  }									\
									\
  /* Final portion.  Note that the buffer must be empty if there is a	\
   * tail, since otherwise the input data would have been part of the	\
   * head portion instad. */						\
  if (!plan.tail)							\
    BLKC_STORE(PRE, ctx->b, t);						\
  else {								\
    pre##_eblk(&ctx->ctx, t, t);					\
    BLKC_STORE(PRE, ctx->b, t);						\
    p = ctx->b; ctx->off += plan.tail;					\
    if (s) while (plan.tail--) { y = *s++ ^ *p; *p++ = y; if (d) *d++ = y; } \
    else if (d) { memcpy(d, p, plan.tail); d += plan.tail; }		\
  }									\
}									\
									\
/* --- @pre_cfbdecrypt@ --- *						\
 *									\
 * 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)					\
{									\
  rsvr_plan plan;							\
  const octet *s = src;							\
  octet *d = dest, *p;							\
  uint32 t[PRE##_BLKSZ/4], u[PRE##_BLKSZ/4];				\
  octet y;								\
									\
  /* Construct a plan and prepare to follow through. */			\
  rsvr_mkplan(&plan, &pre##_cfbpolicy, ctx->off, sz);			\
  BLKC_LOAD(PRE, t, ctx->b);						\
									\
  /* Initial portion, fulfilled from the buffer.  If the chunk is small	\
   * enough, then this will be the only portion.  If the buffer is	\
   * currently empty, then we must prepare it.				\
   */									\
  if (plan.head) {							\
    if (!ctx->off) {							\
      pre##_eblk(&ctx->ctx, t, t);					\
      BLKC_STORE(PRE, ctx->b, t);					\
    }									\
    p = ctx->b + ctx->off;						\
    ctx->off += plan.head;						\
    while (plan.head--) { y = *s++; *d++ = y ^ *p; *p++ = y; }		\
    BLKC_LOAD(PRE, t, ctx->b);						\
  }									\
									\
  /* If the buffer is all used, then reset it ready for next time. */	\
  ctx->off -= plan.from_rsvr;						\
									\
  /* Handle multiple whole blocks. */					\
  while (plan.from_input) {						\
    pre##_eblk(&ctx->ctx, t, t);					\
    BLKC_LOAD(PRE, u, s); s += PRE##_BLKSZ;				\
    BLKC_XSTORE(PRE, d, t, u); d += PRE##_BLKSZ;			\
    BLKC_MOVE(PRE, t, u);						\
    plan.from_input -= PRE##_BLKSZ;					\
  }									\
									\
  /* Final portion.  Note that the buffer must be empty if there is a	\
   * tail, since otherwise the input data would have been part of the	\
   * head portion instad. */						\
  if (!plan.tail)							\
    BLKC_STORE(PRE, ctx->b, t);						\
  else {								\
    pre##_eblk(&ctx->ctx, t, t);					\
    BLKC_STORE(PRE, ctx->b, t);						\
    p = ctx->b;								\
    ctx->off += plan.tail;						\
    while (plan.tail--) { y = *s++; *d++ = y ^ *p; *p++ = y; }		\
  }									\
}									\
									\
/* --- 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 = S_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; BURN(*g); S_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,								\
  gencrypt, gdecrypt, gdestroy, gsetiv, gbdry				\
};									\
									\
const gccipher pre##_cfb = {						\
  name "-cfb", pre##_keysz, PRE##_BLKSZ,				\
  ginit									\
};									\
									\
CFB_TESTX(PRE, pre, name, fname)

/*----- Test rig ----------------------------------------------------------*/

#define CFB_TEST(PRE, pre) CFB_TESTX(PRE, pre, #pre, #pre)

#ifdef TEST_RIG

#include "modes-test.h"

/* --- @CFB_TEST@ --- *
 *
 * Arguments:	@PRE@, @pre@ = prefixes for block cipher definitions
 *
 * Use:		Standard test rig for CFB functions.
 */

#define CFB_TESTX(PRE, pre, name, fname)				\
									\
static pre##_ctx key;							\
static pre##_cfbctx ctx;						\
									\
static void pre##_cfb_test_setup(const octet *k, size_t ksz)		\
  { pre##_init(&key, k, ksz); pre##_cfbsetkey(&ctx, &key); }		\
									\
static void pre##_cfb_test_reset(const octet *iv)			\
  { pre##_cfbsetiv(&ctx, iv); }						\
									\
static void pre##_cfb_test_enc(const octet *s, octet *d, size_t sz)	\
  { pre##_cfbencrypt(&ctx, s, d, sz); }					\
									\
static void pre##_cfb_test_dec(const octet *s, octet *d, size_t sz)	\
  { pre##_cfbdecrypt(&ctx, s, d, sz); }					\
									\
int main(int argc, char *argv[])					\
{									\
  return test_encmode(fname "-cfb", PRE##_KEYSZ, PRE##_BLKSZ, 1, 0,	\
		      pre##_cfb_test_setup, pre##_cfb_test_reset,	\
		      pre##_cfb_test_enc, pre##_cfb_test_dec,		\
		      argc, argv);					\
}

#else
#  define CFB_TESTX(PRE, pre, name, fname)
#endif

/*----- That's all, folks -------------------------------------------------*/

#ifdef __cplusplus
  }
#endif

#endif