Add fill for encryption schemes.

[catacomb-perl] / algorithms.xs

# ---?---
#
# $Id$
#
# Interface to crypto algorithms
#
# (c) 2001 Straylight/Edgeware
#

#----- Licensing notice -----------------------------------------------------
#
# This file is part of the Perl interface to Catacomb.
#
# Catacomb/Perl is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# 
# Catacomb/Perl 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 General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with Catacomb/Perl; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

MODULE = Catacomb PACKAGE = Catacomb::PRPClass

PRPClass *
find(me, name)
	SV *me
	char *name
	PREINIT:
	int i;
	CODE:
	RETVAL = 0;
	for (i = 0; prptab[i]; i++) {
	  if (strcmp(name, prptab[i]->name) == 0) {
	    RETVAL = prptab[i];
	    break;
	  }
	}
	OUTPUT:
	RETVAL

SV *
list(me)
	SV *me
	PREINIT:
	int i;
	PPCODE:
	for (i = 0; prptab[i]; i++)
	  XPUSHs(RET(prptab[i], "Catacomb::PRPClass"));

keysize *
keysz(p)
	PRPClass *p
	CODE:
	RETVAL = p->ksz;
	OUTPUT:
	RETVAL

char *
name(p)
	PRPClass *p
	CODE:
	RETVAL = p->name;
	OUTPUT:
	RETVAL

UV
blksz(p)
	PRPClass *p
	CODE:
	RETVAL = p->blksz;
	OUTPUT:
	RETVAL

PRP *
init(p, k)
	PRPClass *p
	SV *k
	PREINIT:
	char *pp;
	STRLEN len;
	CODE:
	pp = SvPV(k, len);
	if (keysz(len, p->ksz) != len)
	  croak("key size mismatch");
	RETVAL = sub_alloc(sizeof(PRP) + p->ctxsz);
	RETVAL->c = p;
	p->init(RETVAL + 1, pp, len);
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::PRP

SV *
DESTROY(p)
	PRP *p
	CODE:
	sub_free(p, sizeof(PRP) + p->c->ctxsz);
	XSRETURN_YES;

SV *
eblk(p, x)
	PRP *p
	SV *x
	PREINIT:
	char *pp;
	STRLEN len;
	CODE:
	pp = SvPV(x, len);
	if (len != p->c->blksz)
	  croak("block size mismatch");
	RETVAL = NEWSV(0, p->c->blksz);
	p->c->eblk(p + 1, pp, SvPVX(RETVAL));
	SvPOK_on(RETVAL);
	SvCUR_set(RETVAL, p->c->blksz);
	OUTPUT:
	RETVAL

SV *
dblk(p, x)
	PRP *p
	SV *x
	PREINIT:
	char *pp;
	STRLEN len;
	CODE:
	pp = SvPV(x, len);
	if (len != p->c->blksz)
	  croak("block size mismatch");
	RETVAL = NEWSV(0, p->c->blksz);
	p->c->dblk(p + 1, pp, SvPVX(RETVAL));
	SvPOK_on(RETVAL);
	SvCUR_set(RETVAL, p->c->blksz);
	OUTPUT:
	RETVAL

PRPClass *
class(p)
	PRP *p
	CODE:
	RETVAL = p->c;
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::CipherClass

PROTOTYPES: DISABLE

gccipher *
find(me, name)
	SV *me
	char *name
	CODE:
	RETVAL = (gccipher *)gcipher_byname(name);
	OUTPUT:
	RETVAL

keysize *
keysz(cc)
	gccipher *cc
	CODE:
	RETVAL = cc->keysz;
	OUTPUT:
	RETVAL

char *
name(cc)
	gccipher *cc
	CODE:
	RETVAL = (char *)cc->name;
	OUTPUT:
	RETVAL

size_t
blksz(cc)
	gccipher *cc
	CODE:
	RETVAL = cc->blksz;
	OUTPUT:
	RETVAL

gcipher *
init(cc, k)
	gccipher *cc
	SV *k
	PREINIT:
	STRLEN len;
	char *p;
	CODE:
	p = SvPV(k, len);
	if (keysz(len, cc->keysz) != len) {
	  croak("bad key size %lu for cipher `%s'",
		(unsigned long)len, cc->name);
	}
	RETVAL = cc->init(p, len);
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Cipher

SV *
DESTROY(c)
	gcipher *c
	CODE:
	c->ops->destroy(c);
	XSRETURN_YES;

SV *
encrypt(c, plain)
	gcipher *c
	SV *plain
	PREINIT:
	STRLEN len;
	char *p;
	CODE:
	p = SvPV(plain, len);
	RETVAL = NEWSV(0, len ? len : 1);
	c->ops->encrypt(c, p, SvPVX(RETVAL), len);
	SvCUR_set(RETVAL, len);
	SvPOK_on(RETVAL);
	OUTPUT:
	RETVAL

SV *
fill(c, len)
	gcipher *c
	size_t len;
	CODE:
	RETVAL = NEWSV(0, len ? len : 1);
	memset(SvPVX(RETVAL), 0, len);
	c->ops->encrypt(c, SvPVX(RETVAL), SvPVX(RETVAL), len);
	SvCUR_set(RETVAL, len);
	SvPOK_on(RETVAL);
	OUTPUT:
	RETVAL

SV *
decrypt(c, cipher)
	gcipher *c
	SV *cipher
	PREINIT:
	STRLEN len;
	char *p;
	CODE:
	p = SvPV(cipher, len);
	RETVAL = NEWSV(0, len ? len : 1);
	c->ops->decrypt(c, p, SvPVX(RETVAL), len);
	SvCUR_set(RETVAL, len);
	SvPOK_on(RETVAL);
	OUTPUT:
	RETVAL

SV *
filldecrypt(c, len)
	gcipher *c
	size_t len;
	CODE:
	RETVAL = NEWSV(0, len ? len : 1);
	memset(SvPVX(RETVAL), 0, len);
	c->ops->decrypt(c, SvPVX(RETVAL), SvPVX(RETVAL), len);
	SvCUR_set(RETVAL, len);
	SvPOK_on(RETVAL);
	OUTPUT:
	RETVAL

SV *
setiv(c, iv)
	gcipher *c
	SV *iv
	PREINIT:
	STRLEN len;
	char *p;
	CODE:
	p = SvPV(iv, len);
	if (c->ops->c->blksz && len != c->ops->c->blksz) {
	  croak("IV for block cipher `%s' must be %lu",
		c->ops->c->name, (unsigned long)c->ops->c->blksz);
	}
	c->ops->setiv(c, p);
	XSRETURN_YES;

SV *
bdry(c)
	gcipher *c
	CODE:
	c->ops->bdry(c);
	XSRETURN_YES;

gccipher *
class(c)
	gcipher *c
	CODE:
	RETVAL = (gccipher *)c->ops->c;
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::HashClass

gchash *
find(me, name)
	SV *me
	char *name
	CODE:
	RETVAL = (gchash *)ghash_byname(name);
	OUTPUT:
	RETVAL

size_t
hashsz(hc)
	gchash *hc
	CODE:
	RETVAL = hc->hashsz;
	OUTPUT:
	RETVAL

char *
name(hc)
	gchash *hc
	CODE:
	RETVAL = (char *)hc->name;
	OUTPUT:
	RETVAL

ghash *
init(hc)
	gchash *hc
	CODE:
	RETVAL = hc->init();
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Hash

SV *
DESTROY(h)
	ghash *h
	CODE:
	h->ops->destroy(h);
	XSRETURN_YES;

SV *
hash(h, sv)
	ghash *h
	SV *sv
	PREINIT:
	STRLEN len;
	char *p;
	CODE:
	p = SvPV(sv, len);
	h->ops->hash(h, p, len);
	XSRETURN_YES;

SV *
done(h)
	ghash *h
	CODE:
	RETVAL = NEWSV(0, h->ops->c->hashsz);
	h->ops->done(h, SvPVX(RETVAL));
	SvCUR_set(RETVAL, h->ops->c->hashsz);
	SvPOK_on(RETVAL);
	OUTPUT:
	RETVAL

ghash *
copy(h)
	ghash *h
	CODE:
	RETVAL = h->ops->copy(h);
	OUTPUT:
	RETVAL

gchash *
class(h)
	ghash *h
	CODE:
	RETVAL = (gchash *)h->ops->c;
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::MACClass

gcMAC *
find(me, name)
	SV *me
	char *name
	CODE:
	RETVAL = (gcMAC *)gmac_byname(name);
	OUTPUT:
	RETVAL

SV *
list(me)
	SV *me
	PREINIT:
	const gcMAC *const *mc;
	PPCODE:
	for (mc = gmactab; *mc; mc++)
	  XPUSHs(RET((gcMAC *)*mc, "Catacomb::MACClass"));

size_t
hashsz(mc)
	gcMAC *mc
	CODE:
	RETVAL = mc->hashsz;
	OUTPUT:
	RETVAL

keysize *
keysz(mc)
	gcMAC *mc
	CODE:
	RETVAL = mc->keysz;
	OUTPUT:
	RETVAL

char *
name(mc)
	gcMAC *mc
	CODE:
	RETVAL = (char *)mc->name;
	OUTPUT:
	RETVAL

gMAC *
key(mc, k)
	gcMAC *mc
	SV *k
	PREINIT:
	STRLEN len;
	char *p;
	CODE:
	p = SvPV(k, len);
	if (keysz(len, mc->keysz) != len) {
	  croak("bad key size %lu for mac `%s'",
		(unsigned long)len, mc->name);
	}
	RETVAL = mc->key(p, len);
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::MAC

SV *
DESTROY(m)
	gMAC *m
	CODE:
	m->ops->destroy(m);
	XSRETURN_YES;

ghash *
init(m)
	gMAC *m
	CODE:
	RETVAL = m->ops->init(m);
	OUTPUT:
	RETVAL

gcMAC *
class(m)
	gMAC *m
	CODE:
	RETVAL = (gcMAC *)m->ops->c;
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Rand

SV *
seedint(r, seed)
	grand *r
	U32 seed
	CODE:
	if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDUINT32))
	  croak("rng `%s' doesn't support `seedint'", r->ops->name);
	r->ops->misc(r, GRAND_SEEDUINT32, seed);
	XSRETURN_YES;

SV *
seedblock(r, seed)
	grand *r
	SV *seed
	PREINIT:
	STRLEN len;
	char *p;
	CODE:
	if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDBLOCK))
	  croak("rng `%s' doesn't support `seedblock'", r->ops->name);
	p = SvPV(seed, len);
	r->ops->misc(r, GRAND_SEEDBLOCK, p, len);
	XSRETURN_YES;

SV *
seedmp(r, seed)
	grand *r
	mp *seed
	CODE:
	if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDMP))
	  croak("rng `%s' doesn't support `seedmp'", r->ops->name);
	r->ops->misc(r, GRAND_SEEDMP, seed);
	XSRETURN_YES;

SV *
seedrand(r, seed)
	grand *r
	grand *seed
	CODE:
	if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDRAND))
	  croak("rng `%s' doesn't support `seedrand'", r->ops->name);
	r->ops->misc(r, GRAND_SEEDRAND, seed);
	XSRETURN_YES;

U32
raw(r)
	grand *r
	CODE:
	RETVAL = r->ops->raw(r);
	OUTPUT:
	RETVAL

U32
word(r)
	grand *r
	CODE:
	RETVAL = r->ops->word(r);
	OUTPUT:
	RETVAL

U8
byte(r)
	grand *r
	CODE:
	RETVAL = r->ops->byte(r);
	OUTPUT:
	RETVAL

char
char(r)
	grand *r
	CODE:
	RETVAL = r->ops->byte(r);
	OUTPUT:
	RETVAL

U32
range(r, limit)
	grand *r
	U32 limit
	CODE:
	RETVAL = r->ops->range(r, limit);
	OUTPUT:
	RETVAL

mp *
mp(r, bits, or = 0)
	grand *r
	unsigned or
	unsigned bits
	CODE:
	RETVAL = mprand(MP_NEW, bits, r, or);
	OUTPUT:
	RETVAL

mp *
mprange(r, limit)
	grand *r
	mp *limit
	CODE:
	RETVAL = mprand_range(MP_NEW, limit, r, 0);
	OUTPUT:
	RETVAL

SV *
fill(r, n)
	grand *r
	size_t n
	CODE:
	RETVAL = NEWSV(0, n ? n : 1);
	r->ops->fill(r, SvPVX(RETVAL), n);
	SvCUR_set(RETVAL, n);
	SvPOK_on(RETVAL);
	OUTPUT:
	RETVAL

char *
name(r)
	grand *r
	CODE:
	RETVAL = (char *)r->ops->name;
	OUTPUT:
	RETVAL

U32
flags(r)
	grand *r
	CODE:
	RETVAL = r->ops->f;
	OUTPUT:
	RETVAL

U32
max(r)
	grand *r
	CODE:
	RETVAL = r->ops->max;
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Rand::True

Rand_True *
_global(me)
	SV *me
	CODE:
	RETVAL = &rand_global;
	OUTPUT:
	RETVAL

Rand_True *
rand(me)
	SV *me
	CODE:
	RETVAL = rand_create();
	OUTPUT:
	RETVAL

SV *
gate(r)
	Rand_True *r
	CODE:
	r->ops->misc(r, RAND_GATE);
	XSRETURN_YES;

SV *
stretch(r)
	Rand_True *r
	CODE:
	r->ops->misc(r, RAND_STRETCH);
	XSRETURN_YES;

SV *
key(r, k)
	Rand_True *r
	SV *k
	PREINIT:
	STRLEN len;
	char *p;
	CODE:
	p = SvPV(k, len);
	r->ops->misc(r, RAND_KEY, p, len);
	XSRETURN_YES;

SV *
noisesrc(r)
	Rand_True *r
	CODE:
	r->ops->misc(r, RAND_NOISESRC, &noise_source);
	XSRETURN_YES;

SV *
seed(r, bits = 160)
	Rand_True *r
	int bits
	CODE:
	r->ops->misc(r, RAND_SEED, bits);
	XSRETURN_YES;

MODULE = Catacomb PACKAGE = Catacomb::Rand::Fib

SV *
new(me, seed)
	SV *me
	U32 seed
	CODE:
	RETVAL = MAKE(fibrand_create(seed), "Catacomb::Rand::Fib");
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Rand::LC

SV *
new(me, seed)
	SV *me
	U32 seed
	CODE:
	RETVAL = MAKE(lcrand_create(seed), "Catacomb::Rand::LC");
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Rand::DSA

Rand_DSA *
new(me, k)
	SV *me
	SV *k
	PREINIT:
	STRLEN len;
	char *p;
	CODE:
	p = SvPV(k, len);
	RETVAL = dsarand_create(p, len);
	OUTPUT:
	RETVAL

SV *
passes(r, n)
	Rand_DSA *r
	unsigned n
	CODE:
	r->ops->misc(r, DSARAND_PASSES, n);
	XSRETURN_YES;

SV *
seed(r)
	Rand_DSA *r
	PREINIT:
	size_t sz;
	CODE:
	sz = r->ops->misc(r, DSARAND_SEEDSZ);
	RETVAL = NEWSV(0, sz ? sz : 1);
	r->ops->misc(r, DSARAND_GETSEED, SvPVX(RETVAL));
	SvCUR_set(RETVAL, sz);
	SvPOK_on(RETVAL);
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Rand::RC4

SV *
new(me, k)
	SV *me
	SV *k
	PREINIT:
	STRLEN len;
	char *p;
	CODE:
	p = SvPV(k, len);
	RETVAL = MAKE(rc4_rand(p, len), "Catacomb::Rand::RC4");
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Rand::SEAL

SV *
new(me, k, n = 0)
	SV *me
	SV *k
	U32 n
	PREINIT:
	STRLEN len;
	char *p;
	CODE:
	p = SvPV(k, len);
	RETVAL = MAKE(seal_rand(p, len, n), "Catacomb::Rand::SEAL");
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Rand::MGF

SV *
new(me, name, k)
	SV *me
	char *name
	SV *k
	CODE:
	RETVAL = findrand(mgftab, "Catacomb::Rand::MGF", name, k);
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Rand::Counter

SV *
new(me, name, k)
	SV *me
	char *name
	SV *k
	CODE:
	RETVAL = findrand(ctrtab, "Catacomb::Rand::Counter", name, k);
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Rand::OFB

SV *
new(me, name, k)
	SV *me
	char *name
	SV *k
	CODE:
	RETVAL = findrand(ofbtab, "Catacomb::Rand::OFB", name, k);
	OUTPUT:
	RETVAL

MODULE = Catacomb PACKAGE = Catacomb::Rand::Magic

SV *
DESTROY(r)
	grand *r
	CODE:
	XSRETURN_YES;

#----- That's all, folks ----------------------------------------------------