[catacomb] / symm / hash.h

/* -*-c-*-
 *
 * Generic handling for message digest functions
 *
 * (c) 1998 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_HASH_H
#define CATACOMB_HASH_H

#ifdef __cplusplus
  extern "C" {
#endif

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

#include <string.h>

#include <mLib/bits.h>

#ifndef CATACOMB_RSVR_H
#  include "rsvr.h"
#endif

/*----- Macros ------------------------------------------------------------*/

/* --- @HASH_BUFFER@ --- *
 *
 * Arguments:	@PRE@, @pre@ = prefixes for hash-specific definitions
 *		@ictx@ = pointer to context block for the hash
 *		@ibuf@ = pointer to input data to hash
 *		@isz@ = size of buffer
 *
 * Use:		Handles buffering of input data to a hash function.  The
 *		hash's compression function is called when the buffer is
 *		full.  Note that the compression function can be called on
 *		data which is at odd alignments; it is expected to cope
 *		gracefully with this (possibly by copying the data into its
 *		internal buffer before starting).
 */

#define HASH_BUFFER(PRE, pre, ictx, ibuf, isz) do {			\
  pre##_ctx *_bctx = (ictx);						\
  size_t _bsz = (isz);							\
  const octet *_bbuf = (octet *)(ibuf), *_p;				\
  static const rsvr_policy _pol = { 0, PRE##_BUFSZ, PRE##_BUFSZ };	\
  uint32 _l, _h;							\
  rsvr_state _st;							\
									\
  /* --- Add on the size done so far --- *				\
   *									\
   * Messy, because trapping overflow is difficult when you don't know	\
   * how many bits you've actually got.					\
   */									\
									\
  _l = U32(_bsz); _h = ((_bsz & ~(size_t)MASK32) >> 16) >> 16;		\
  _bctx->nl += _l; if (_bctx->nl < _l || _bctx->nl & ~(uint32)MASK32) _h++; \
  _bctx->nh += _h;							\
									\
  /* --- Accumulate the input data --- */				\
									\
  rsvr_setup(&_st, &_pol, _bctx->buf, &_bctx->off, _bbuf, _bsz);	\
  RSVR_DO(&_st) while ((_p = RSVR_NEXT(&_st, PRE##_BUFSZ)) != 0)	\
    pre##_compress(_bctx, _p);						\
} while (0)

/* --- @HASH_PAD@ --- *
 *
 * Arguments:	@PRE@, @pre@ = prefixes for hash-specific definitions
 *		@ictx@ = pointer to context block for the hash
 *		@term@ = terminator character to write following the data
 *		@pad@ = pad character to fill with
 *		@diff@ = size of space to leave at the end of the last block
 *
 * Use:		Does padding for message digest functions.
 */

#define HASH_PAD(PRE, pre, ictx, term, pad, diff) do {			\
  pre##_ctx *_pctx = (ictx);						\
									\
  _pctx->buf[_pctx->off] = term;					\
  _pctx->off++;								\
  if (_pctx->off > PRE##_BUFSZ - diff) {				\
    if (_pctx->off < PRE##_BUFSZ)					\
      memset(_pctx->buf + _pctx->off, pad, PRE##_BUFSZ - _pctx->off);	\
    pre##_compress(_pctx, _pctx->buf);					\
    memset(_pctx->buf, pad, PRE##_BUFSZ - diff);			\
  } else								\
    memset(_pctx->buf + _pctx->off, pad,				\
	   PRE##_BUFSZ - _pctx->off - diff);				\
} while (0)

/* --- @HASH_MD5STRENGTH@ --- *
 *
 * Arguments:	@PRE@, @pre@ = prefixes for hash-specific definitions
 *		@ictx@ = pointer to context block for the hash
 *
 * Use:		Does MD5-style MD strengthening.  The data is terminated
 *		by a single set bit, padded with zero bits, and then a 64-
 *		bit length is written, little-end first.
 */

#define HASH_MD5STRENGTH(PRE, pre, ictx) do {				\
  pre##_ctx *_mctx = (ictx);						\
  HASH_PAD(PRE, pre, _mctx, 0x80u, 0, 8);				\
  STORE32_L(_mctx->buf + PRE##_BUFSZ - 8, _mctx->nl << 3);		\
  STORE32_L(_mctx->buf + PRE##_BUFSZ - 4,				\
	    (_mctx->nl >> 29) | (_mctx->nh << 3));			\
  pre##_compress(_mctx, _mctx->buf);					\
} while (0)

/* --- @HASH_TEST@ --- *
 *
 * Arguments:	@PRE@, @pre@ = prefixes for hash-specfic definitions
 *
 * Use:		Standard test rig for hash functions.
 */

#ifdef TEST_RIG

#include <mLib/quis.h>
#include <mLib/testrig.h>

#define HASH_BUFLEN 100000

#define HASH_VERIFY(PRE, pre) HASH_VERIFYX(PRE, pre, #pre)

#define HASH_VERIFYX(PRE, pre, name)					\
									\
static int vrf_##pre(dstr *v, const test_type *msgty)			\
{									\
  pre##_ctx ctx;							\
  int ok = 1;								\
  int i;								\
  octet *p;								\
  int szs[] = { 1, 7, 192, -1, 0 }, *ip;				\
  size_t sz;								\
  dstr d;								\
									\
  dstr_create(&d);							\
  dstr_ensure(&d, PRE##_HASHSZ);					\
  d.len = PRE##_HASHSZ;							\
									\
  for (ip = szs; *ip; ip++) {						\
    i = *ip;								\
    sz = v[0].len;							\
    if (i == -1)							\
      i = sz;								\
    if (i > sz)								\
      continue;								\
    p = (octet *)v[0].buf;						\
    pre##_init(&ctx);							\
    while (sz) {							\
      if (i > sz)							\
	i = sz;								\
      pre##_hash(&ctx, p, i);						\
      p += i;								\
      sz -= i;								\
    }									\
    pre##_done(&ctx, d.buf);						\
    if (memcmp(d.buf, v[1].buf, PRE##_HASHSZ) != 0) {			\
      printf("\nfail:\n\tstep = %i\n\tinput = ", *ip);			\
      msgty->dump(&v[0], stdout);					\
      printf("\n\texpected = ");					\
      type_hex.dump(&v[1], stdout);					\
      fputs("\n\tcomputed = ", stdout);					\
      type_hex.dump(&d, stdout);					\
      putchar('\n');							\
      ok = 0;								\
    }									\
  }									\
									\
  dstr_destroy(&d);							\
  return (ok);								\
}									\
									\
static int vrf_##pre##_hex(dstr *v)					\
  { return vrf_##pre(v, &type_hex); }					\
static int vrf_##pre##_lit(dstr *v)					\
  { return vrf_##pre(v, &type_string); }				\
									\
static int vrf_##pre##_rep(dstr *v)					\
{									\
  pre##_ctx ctx;							\
  size_t len = v[0].len;						\
  int n = *(int *)v[1].buf;						\
  int nd = 0;								\
  int nn = len;								\
  int ok = 1;								\
  octet *p, *q;								\
  dstr d = DSTR_INIT;							\
									\
  while (nn < HASH_BUFLEN && (n & 1) == 0) { nd++; nn <<= 1; n >>= 1; }	\
  p = xmalloc(nn);							\
  memcpy(p, v[0].buf, len);						\
  q = p + len;								\
  while (nd--) { memcpy(q, p, len); q += len; len <<= 1; }		\
									\
  dstr_ensure(&d, PRE##_HASHSZ);					\
  d.len = PRE##_HASHSZ;							\
  pre##_init(&ctx);							\
  while (n--) pre##_hash(&ctx, p, len);					\
  pre##_done(&ctx, d.buf);						\
									\
  if (memcmp(d.buf, v[2].buf, PRE##_HASHSZ) != 0) {			\
    printf("\nfail:\n\tinput = `%s'\n\treps = `%i'\n\texpected = ",	\
	     v[0].buf, *(int *)v[1].buf);				\
    type_hex.dump(&v[2], stdout);					\
    fputs("\n\tcomputed = ", stdout);					\
    type_hex.dump(&d, stdout);						\
    putchar('\n');							\
    ok = 0;								\
  }									\
  xfree(p);								\
  dstr_destroy(&d);							\
  return (ok);								\
}

#define HASH_TESTDEFS(PRE, pre) HASH_TESTDEFSX(PRE, pre, #pre)

#define HASH_TESTDEFSX(PRE, pre, name)					\
  { name, vrf_##pre##_lit, { &type_string, &type_hex, 0 } },		\
  { name "-hex", vrf_##pre##_hex, { &type_hex, &type_hex, 0 } },	\
  { name "-rep", vrf_##pre##_rep,					\
    { &type_string, &type_int, &type_hex, 0 } },

#define HASH_TESTX(PRE, pre, name, fname)				\
									\
HASH_VERIFYX(PRE, pre, name)						\
									\
static test_chunk defs[] = {						\
  HASH_TESTDEFSX(PRE, pre, name)					\
  { 0, 0, { 0 } }							\
};									\
									\
int main(int argc, char *argv[])					\
{									\
  ego(argv[0]);								\
  test_run(argc, argv, defs, SRCDIR"/t/" fname);			\
  return (0);								\
}

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

#define HASH_TEST(PRE, pre) HASH_TESTX(PRE, pre, #pre, #pre)

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

#ifdef __cplusplus
  }
#endif

#endif
Commit	Line	Data
d03ab969	1	/* --c--
d03ab969	2	*
d03ab969	3	* Generic handling for message digest functions
	4	*
	5	* (c) 1998 Straylight/Edgeware
	6	*/
	7
45c0fd36	8	/----- Licensing notice --------------------------------------------------
d03ab969	9	*
	10	* This file is part of Catacomb.
	11	*
	12	* Catacomb is free software; you can redistribute it and/or modify
	13	* it under the terms of the GNU Library General Public License as
	14	* published by the Free Software Foundation; either version 2 of the
	15	* License, or (at your option) any later version.
45c0fd36	16	*
d03ab969	17	* Catacomb is distributed in the hope that it will be useful,
	18	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	* GNU Library General Public License for more details.
45c0fd36	21	*
d03ab969	22	* You should have received a copy of the GNU Library General Public
	23	* License along with Catacomb; if not, write to the Free
	24	* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	25	* MA 02111-1307, USA.
	26	*/
	27
79ba130c	28	#ifndef CATACOMB_HASH_H
79ba130c	29	#define CATACOMB_HASH_H
d03ab969	30
	31	#ifdef __cplusplus
	32	extern "C" {
	33	#endif
	34
	35	/----- Header files ------------------------------------------------------/
	36
	37	#include <string.h>
	38
	39	#include <mLib/bits.h>
	40
6a0eb244 MW	41	#ifndef CATACOMB_RSVR_H
	42	# include "rsvr.h"
	43	#endif
	44
d03ab969	45	/----- Macros ------------------------------------------------------------/
	46
	47	/* --- @HASH_BUFFER@ --- *
	48	*
	49	* Arguments: @PRE@, @pre@ = prefixes for hash-specific definitions
	50	* @ictx@ = pointer to context block for the hash
	51	* @ibuf@ = pointer to input data to hash
	52	* @isz@ = size of buffer
	53	*
	54	* Use: Handles buffering of input data to a hash function. The
	55	* hash's compression function is called when the buffer is
	56	* full. Note that the compression function can be called on
	57	* data which is at odd alignments; it is expected to cope
	58	* gracefully with this (possibly by copying the data into its
	59	* internal buffer before starting).
	60	*/
	61
	62	#define HASH_BUFFER(PRE, pre, ictx, ibuf, isz) do { \
	63	pre##_ctx *_bctx = (ictx); \
	64	size_t _bsz = (isz); \
6a0eb244 MW	65	const octet _bbuf = (octet )(ibuf), *_p; \
6a0eb244 MW	66	static const rsvr_policy _pol = { 0, PRE##_BUFSZ, PRE##_BUFSZ }; \
0fee61eb	67	uint32 _l, _h; \
6a0eb244	68	rsvr_state _st; \
d03ab969	69	\
79ba130c	70	/* --- Add on the size done so far --- * \
	71	* \
	72	* Messy, because trapping overflow is difficult when you don't know \
	73	* how many bits you've actually got. \
	74	*/ \
d03ab969	75	\
0fee61eb MW	76	_l = U32(_bsz); _h = ((_bsz & ~(size_t)MASK32) >> 16) >> 16; \
	77	_bctx->nl += _l; if (_bctx->nl < _l \|\| _bctx->nl & ~(uint32)MASK32) _h++; \
	78	_bctx->nh += _h; \
d03ab969	79	\
6a0eb244	80	/* --- Accumulate the input data --- */ \
d03ab969	81	\
6a0eb244 MW	82	rsvr_setup(&_st, &_pol, _bctx->buf, &_bctx->off, _bbuf, _bsz); \
	83	RSVR_DO(&_st) while ((_p = RSVR_NEXT(&_st, PRE##_BUFSZ)) != 0) \
	84	pre##_compress(_bctx, _p); \
d03ab969	85	} while (0)
	86
	87	/* --- @HASH_PAD@ --- *
	88	*
	89	* Arguments: @PRE@, @pre@ = prefixes for hash-specific definitions
	90	* @ictx@ = pointer to context block for the hash
	91	* @term@ = terminator character to write following the data
	92	* @pad@ = pad character to fill with
	93	* @diff@ = size of space to leave at the end of the last block
	94	*
	95	* Use: Does padding for message digest functions.
	96	*/
	97
	98	#define HASH_PAD(PRE, pre, ictx, term, pad, diff) do { \
	99	pre##_ctx *_pctx = (ictx); \
	100	\
	101	_pctx->buf[_pctx->off] = term; \
	102	_pctx->off++; \
	103	if (_pctx->off > PRE##_BUFSZ - diff) { \
	104	if (_pctx->off < PRE##_BUFSZ) \
	105	memset(_pctx->buf + _pctx->off, pad, PRE##_BUFSZ - _pctx->off); \
	106	pre##_compress(_pctx, _pctx->buf); \
	107	memset(_pctx->buf, pad, PRE##_BUFSZ - diff); \
	108	} else \
	109	memset(_pctx->buf + _pctx->off, pad, \
	110	PRE##_BUFSZ - _pctx->off - diff); \
	111	} while (0)
	112
	113	/* --- @HASH_MD5STRENGTH@ --- *
	114	*
	115	* Arguments: @PRE@, @pre@ = prefixes for hash-specific definitions
	116	* @ictx@ = pointer to context block for the hash
	117	*
	118	* Use: Does MD5-style MD strengthening. The data is terminated
	119	* by a single set bit, padded with zero bits, and then a 64-
	120	* bit length is written, little-end first.
	121	*/
	122
	123	#define HASH_MD5STRENGTH(PRE, pre, ictx) do { \
	124	pre##_ctx *_mctx = (ictx); \
	125	HASH_PAD(PRE, pre, _mctx, 0x80u, 0, 8); \
79ba130c	126	STORE32_L(_mctx->buf + PRE##_BUFSZ - 8, _mctx->nl << 3); \
	127	STORE32_L(_mctx->buf + PRE##_BUFSZ - 4, \
	128	(_mctx->nl >> 29) \| (_mctx->nh << 3)); \
d03ab969	129	pre##_compress(_mctx, _mctx->buf); \
	130	} while (0)
	131
	132	/* --- @HASH_TEST@ --- *
	133	*
	134	* Arguments: @PRE@, @pre@ = prefixes for hash-specfic definitions
	135	*
	136	* Use: Standard test rig for hash functions.
	137	*/
	138
	139	#ifdef TEST_RIG
	140
	141	#include <mLib/quis.h>
	142	#include <mLib/testrig.h>
	143
e9926004	144	#define HASH_BUFLEN 100000
e9926004	145
4328f746 MW	146	#define HASH_VERIFY(PRE, pre) HASH_VERIFYX(PRE, pre, #pre)
	147
	148	#define HASH_VERIFYX(PRE, pre, name) \
d03ab969	149	\
cf9d9d38	150	static int vrf_##pre(dstr v, const test_type msgty) \
d03ab969	151	{ \
	152	pre##_ctx ctx; \
	153	int ok = 1; \
	154	int i; \
	155	octet *p; \
	156	int szs[] = { 1, 7, 192, -1, 0 }, *ip; \
	157	size_t sz; \
	158	dstr d; \
	159	\
	160	dstr_create(&d); \
	161	dstr_ensure(&d, PRE##_HASHSZ); \
	162	d.len = PRE##_HASHSZ; \
	163	\
	164	for (ip = szs; *ip; ip++) { \
	165	i = *ip; \
	166	sz = v[0].len; \
	167	if (i == -1) \
	168	i = sz; \
	169	if (i > sz) \
	170	continue; \
	171	p = (octet *)v[0].buf; \
	172	pre##_init(&ctx); \
	173	while (sz) { \
	174	if (i > sz) \
	175	i = sz; \
	176	pre##_hash(&ctx, p, i); \
	177	p += i; \
	178	sz -= i; \
	179	} \
	180	pre##_done(&ctx, d.buf); \
	181	if (memcmp(d.buf, v[1].buf, PRE##_HASHSZ) != 0) { \
cf9d9d38 MW	182	printf("\nfail:\n\tstep = %i\n\tinput = ", *ip); \
	183	msgty->dump(&v[0], stdout); \
	184	printf("\n\texpected = "); \
d03ab969	185	type_hex.dump(&v[1], stdout); \
	186	fputs("\n\tcomputed = ", stdout); \
	187	type_hex.dump(&d, stdout); \
	188	putchar('\n'); \
	189	ok = 0; \
	190	} \
	191	} \
	192	\
	193	dstr_destroy(&d); \
	194	return (ok); \
	195	} \
	196	\
cf9d9d38 MW	197	static int vrf_##pre##_hex(dstr *v) \
	198	{ return vrf_##pre(v, &type_hex); } \
	199	static int vrf_##pre##_lit(dstr *v) \
	200	{ return vrf_##pre(v, &type_string); } \
	201	\
4328f746	202	static int vrf_##pre##_rep(dstr *v) \
e9926004	203	{ \
	204	pre##_ctx ctx; \
	205	size_t len = v[0].len; \
	206	int n = (int )v[1].buf; \
	207	int nd = 0; \
	208	int nn = len; \
	209	int ok = 1; \
	210	octet p, q; \
	211	dstr d = DSTR_INIT; \
	212	\
	213	while (nn < HASH_BUFLEN && (n & 1) == 0) { nd++; nn <<= 1; n >>= 1; } \
	214	p = xmalloc(nn); \
	215	memcpy(p, v[0].buf, len); \
	216	q = p + len; \
	217	while (nd--) { memcpy(q, p, len); q += len; len <<= 1; } \
	218	\
	219	dstr_ensure(&d, PRE##_HASHSZ); \
	220	d.len = PRE##_HASHSZ; \
	221	pre##_init(&ctx); \
	222	while (n--) pre##_hash(&ctx, p, len); \
	223	pre##_done(&ctx, d.buf); \
	224	\
	225	if (memcmp(d.buf, v[2].buf, PRE##_HASHSZ) != 0) { \
	226	printf("\nfail:\n\tinput = `%s'\n\treps = `%i'\n\texpected = ", \
	227	v[0].buf, (int )v[1].buf); \
	228	type_hex.dump(&v[2], stdout); \
	229	fputs("\n\tcomputed = ", stdout); \
	230	type_hex.dump(&d, stdout); \
	231	putchar('\n'); \
	232	ok = 0; \
	233	} \
12ed8a1f	234	xfree(p); \
e9926004	235	dstr_destroy(&d); \
e9926004	236	return (ok); \
4328f746 MW	237	}
	238
	239	#define HASH_TESTDEFS(PRE, pre) HASH_TESTDEFSX(PRE, pre, #pre)
	240
	241	#define HASH_TESTDEFSX(PRE, pre, name) \
cf9d9d38 MW	242	{ name, vrf_##pre##_lit, { &type_string, &type_hex, 0 } }, \
cf9d9d38 MW	243	{ name "-hex", vrf_##pre##_hex, { &type_hex, &type_hex, 0 } }, \
4328f746 MW	244	{ name "-rep", vrf_##pre##_rep, \
	245	{ &type_string, &type_int, &type_hex, 0 } },
	246
	247	#define HASH_TESTX(PRE, pre, name, fname) \
	248	\
	249	HASH_VERIFYX(PRE, pre, name) \
e9926004	250	\
d03ab969	251	static test_chunk defs[] = { \
4328f746	252	HASH_TESTDEFSX(PRE, pre, name) \
d03ab969	253	{ 0, 0, { 0 } } \
	254	}; \
	255	\
	256	int main(int argc, char *argv[]) \
	257	{ \
	258	ego(argv[0]); \
aaae9cab	259	test_run(argc, argv, defs, SRCDIR"/t/" fname); \
d03ab969	260	return (0); \
	261	}
	262
	263	#else
aaae9cab	264	# define HASH_TESTX(PRE, pre, name, fname)
d03ab969	265	#endif
d03ab969	266
aaae9cab MW	267	#define HASH_TEST(PRE, pre) HASH_TESTX(PRE, pre, #pre, #pre)
aaae9cab MW	268
d03ab969	269	/----- That's all, folks -------------------------------------------------/
	270
	271	#ifdef __cplusplus
	272	}
	273	#endif
	274
	275	#endif