# ---?---
#
-# $Id: algorithms.xs,v 1.1 2004/04/02 18:04:01 mdw Exp $
+# $Id$
#
# Interface to crypto algorithms
#
# 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
+MODULE = Catacomb PACKAGE = Catacomb::PRPClass
-PROTOTYPES: DISABLE
-
-gccipher *
+PRPClass *
find(me, name)
SV *me
char *name
PREINIT:
- const gccipher **cc;
+ int i;
CODE:
RETVAL = 0;
- for (cc = ciphertab; *cc; cc++) {
- if (strcmp((*cc)->name, name) == 0) {
- RETVAL = (gccipher *)*cc;
+ for (i = 0; prptab[i]; i++) {
+ if (strcmp(name, prptab[i]->name) == 0) {
+ RETVAL = prptab[i];
break;
}
}
list(me)
SV *me
PREINIT:
- const gccipher **cc;
- SV *sv;
+ int i;
PPCODE:
- for (cc = ciphertab; *cc; cc++)
- XPUSHs(RET(*cc, "Catacomb::CipherClass"));
+ 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)
gcipher *c
CODE:
c->ops->destroy(c);
- XSRETURN_UNDEF;
+ XSRETURN_YES;
SV *
encrypt(c, plain)
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
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
c->ops->c->name, (unsigned long)c->ops->c->blksz);
}
c->ops->setiv(c, p);
- XSRETURN_UNDEF;
+ XSRETURN_YES;
SV *
bdry(c)
gcipher *c
CODE:
c->ops->bdry(c);
- XSRETURN_UNDEF;
+ XSRETURN_YES;
gccipher *
class(c)
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;
- }
- }
+ RETVAL = (gchash *)ghash_byname(name);
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
ghash *h
CODE:
h->ops->destroy(h);
- XSRETURN_UNDEF;
+ XSRETURN_YES;
SV *
hash(h, sv)
CODE:
p = SvPV(sv, len);
h->ops->hash(h, p, len);
- XSRETURN_UNDEF;
+ XSRETURN_YES;
SV *
done(h)
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;
- }
- }
+ RETVAL = (gcMAC *)gmac_byname(name);
OUTPUT:
RETVAL
list(me)
SV *me
PREINIT:
- const gcMAC **mc;
- SV *sv;
+ const gcMAC *const *mc;
PPCODE:
- for (mc = mactab; *mc; mc++)
- XPUSHs(RET(*mc, "Catacomb::MACClass"));
+ for (mc = gmactab; *mc; mc++)
+ XPUSHs(RET((gcMAC *)*mc, "Catacomb::MACClass"));
size_t
hashsz(mc)
gMAC *m
CODE:
m->ops->destroy(m);
- XSRETURN_UNDEF;
+ XSRETURN_YES;
ghash *
init(m)
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;
+ XSRETURN_YES;
SV *
seedblock(r, seed)
croak("rng `%s' doesn't support `seedblock'", r->ops->name);
p = SvPV(seed, len);
r->ops->misc(r, GRAND_SEEDBLOCK, p, len);
- XSRETURN_UNDEF;
+ XSRETURN_YES;
SV *
seedmp(r, seed)
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;
+ XSRETURN_YES;
SV *
seedrand(r, seed)
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;
+ XSRETURN_YES;
U32
raw(r)
Rand_True *r
CODE:
r->ops->misc(r, RAND_GATE);
- XSRETURN_UNDEF;
+ XSRETURN_YES;
SV *
stretch(r)
Rand_True *r
CODE:
r->ops->misc(r, RAND_STRETCH);
- XSRETURN_UNDEF;
+ XSRETURN_YES;
SV *
key(r, k)
CODE:
p = SvPV(k, len);
r->ops->misc(r, RAND_KEY, p, len);
- XSRETURN_UNDEF;
+ XSRETURN_YES;
SV *
noisesrc(r)
Rand_True *r
CODE:
r->ops->misc(r, RAND_NOISESRC, &noise_source);
- XSRETURN_UNDEF;
+ XSRETURN_YES;
SV *
seed(r, bits = 160)
int bits
CODE:
r->ops->misc(r, RAND_SEED, bits);
- XSRETURN_UNDEF;
+ XSRETURN_YES;
MODULE = Catacomb PACKAGE = Catacomb::Rand::Fib
unsigned n
CODE:
r->ops->misc(r, DSARAND_PASSES, n);
- XSRETURN_UNDEF;
+ XSRETURN_YES;
SV *
seed(r)
MODULE = Catacomb PACKAGE = Catacomb::Rand::MGF
SV *
-new(name, k)
+new(me, name, k)
+ SV *me
char *name
SV *k
CODE:
OUTPUT:
RETVAL
-void
-list(me)
- SV *me
- PPCODE:
- listrand(mgftab);
-
MODULE = Catacomb PACKAGE = Catacomb::Rand::Counter
SV *
-new(name, k)
+new(me, name, k)
+ SV *me
char *name
SV *k
CODE:
OUTPUT:
RETVAL
-void
-list(me)
- SV *me
- PPCODE:
- listrand(ctrtab);
-
MODULE = Catacomb PACKAGE = Catacomb::Rand::OFB
SV *
-new(name, k)
+new(me, name, k)
+ SV *me
char *name
SV *k
CODE:
OUTPUT:
RETVAL
-void
-list(me)
- SV *me
- PPCODE:
- listrand(ofbtab);
-
MODULE = Catacomb PACKAGE = Catacomb::Rand::Magic
SV *
DESTROY(r)
grand *r
CODE:
- XSRETURN_UNDEF;
+ XSRETURN_YES;
#----- That's all, folks ----------------------------------------------------
~mdw / catacomb-perl / blobdiff