+# ---?---
+#
+# $Id: algorithms.xs,v 1.1 2004/04/02 18:04:01 mdw Exp $
+#
+# 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.
+
+#----- Revision history -----------------------------------------------------
+#
+# $Log: algorithms.xs,v $
+# Revision 1.1 2004/04/02 18:04:01 mdw
+# Initial checkin.
+#
+
+MODULE = Catacomb PACKAGE = Catacomb::CipherClass
+
+PROTOTYPES: DISABLE
+
+gccipher *
+find(me, name)
+ SV *me
+ char *name
+ PREINIT:
+ const gccipher **cc;
+ CODE:
+ RETVAL = 0;
+ for (cc = ciphertab; *cc; cc++) {
+ if (strcmp((*cc)->name, name) == 0) {
+ RETVAL = (gccipher *)*cc;
+ break;
+ }
+ }
+ OUTPUT:
+ RETVAL
+
+SV *
+list(me)
+ SV *me
+ PREINIT:
+ const gccipher **cc;
+ SV *sv;
+ PPCODE:
+ for (cc = ciphertab; *cc; cc++)
+ XPUSHs(RET(*cc, "Catacomb::CipherClass"));
+
+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_UNDEF;
+
+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 *
+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 *
+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_UNDEF;
+
+SV *
+bdry(c)
+ gcipher *c
+ CODE:
+ c->ops->bdry(c);
+ XSRETURN_UNDEF;
+
+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
+ PREINIT:
+ const gchash **hc;
+ CODE:
+ RETVAL = 0;
+ for (hc = hashtab; *hc; hc++) {
+ if (strcmp((*hc)->name, name) == 0) {
+ RETVAL = (gchash *)*hc;
+ break;
+ }
+ }
+ OUTPUT:
+ RETVAL
+
+SV *
+list(me)
+ SV *me
+ PREINIT:
+ const gchash **hc;
+ SV *sv;
+ PPCODE:
+ for (hc = hashtab; *hc; hc++)
+ XPUSHs(RET(*hc, "Catacomb::HashClass"));
+
+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_UNDEF;
+
+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_UNDEF;
+
+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
+ PREINIT:
+ const gcMAC **mc;
+ CODE:
+ RETVAL = 0;
+ for (mc = mactab; *mc; mc++) {
+ if (strcmp((*mc)->name, name) == 0) {
+ RETVAL = (gcMAC *)*mc;
+ break;
+ }
+ }
+ OUTPUT:
+ RETVAL
+
+SV *
+list(me)
+ SV *me
+ PREINIT:
+ const gcMAC **mc;
+ SV *sv;
+ PPCODE:
+ for (mc = mactab; *mc; mc++)
+ XPUSHs(RET(*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_UNDEF;
+
+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_UNDEF;
+
+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_UNDEF;
+
+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_UNDEF;
+
+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_UNDEF;
+
+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_UNDEF;
+
+SV *
+stretch(r)
+ Rand_True *r
+ CODE:
+ r->ops->misc(r, RAND_STRETCH);
+ XSRETURN_UNDEF;
+
+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_UNDEF;
+
+SV *
+noisesrc(r)
+ Rand_True *r
+ CODE:
+ r->ops->misc(r, RAND_NOISESRC, &noise_source);
+ XSRETURN_UNDEF;
+
+SV *
+seed(r, bits = 160)
+ Rand_True *r
+ int bits
+ CODE:
+ r->ops->misc(r, RAND_SEED, bits);
+ XSRETURN_UNDEF;
+
+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_UNDEF;
+
+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(name, k)
+ char *name
+ SV *k
+ CODE:
+ RETVAL = findrand(mgftab, "Catacomb::Rand::MGF", name, k);
+ OUTPUT:
+ RETVAL
+
+void
+list(me)
+ SV *me
+ PPCODE:
+ listrand(mgftab);
+
+MODULE = Catacomb PACKAGE = Catacomb::Rand::Counter
+
+SV *
+new(name, k)
+ char *name
+ SV *k
+ CODE:
+ RETVAL = findrand(ctrtab, "Catacomb::Rand::Counter", name, k);
+ OUTPUT:
+ RETVAL
+
+void
+list(me)
+ SV *me
+ PPCODE:
+ listrand(ctrtab);
+
+MODULE = Catacomb PACKAGE = Catacomb::Rand::OFB
+
+SV *
+new(name, k)
+ char *name
+ SV *k
+ CODE:
+ RETVAL = findrand(ofbtab, "Catacomb::Rand::OFB", name, k);
+ OUTPUT:
+ RETVAL
+
+void
+list(me)
+ SV *me
+ PPCODE:
+ listrand(ofbtab);
+
+MODULE = Catacomb PACKAGE = Catacomb::Rand::Magic
+
+SV *
+DESTROY(r)
+ grand *r
+ CODE:
+ XSRETURN_UNDEF;
+
+#----- That's all, folks ----------------------------------------------------