Key mangling, and elliptic curves.

[catacomb-perl] / field.xs

diff --git a/field.xs b/field.xs
new file mode 100644 (file)
index 0000000..5121979
--- /dev/null
+++ b/field.xs
@@ -0,0 +1,314 @@
+# ---?---
+#
+# $Id$
+#
+# Field abstraction
+#
+# (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::Field PREFIX = field_
+
+Field *
+field_prime(me, p)
+       SV *me
+       mp *p
+       C_ARGS:
+       p
+
+Field *
+field_niceprime(me, p)
+       SV *me
+       mp *p
+       C_ARGS:
+       p
+
+Field *
+field_binpoly(me, p)
+       SV *me
+       gf *p
+       C_ARGS:
+       p
+
+Field *
+field_binnorm(me, p, beta)
+       SV *me
+       gf *p
+       gf *beta
+       C_ARGS:
+       p, beta
+
+Field *
+byname(me, str)
+       SV *me
+       char *str
+       PREINIT:
+       qd_parse qd;
+       CODE:
+       qd.e = 0;
+       qd.p = str;
+       if ((RETVAL = field_parse(&qd)) == 0)
+         croak("bad field spec: %s", qd.e);
+       else if (!qd_eofp(&qd)) {
+         F_DESTROY(RETVAL);
+         croak("junk at end of field spec");
+       }
+       OUTPUT:
+       RETVAL
+
+SV *
+DESTROY(f)
+       Field *f
+       CODE:
+       F_DESTROY(f);
+       XSRETURN_YES;
+
+char *
+name(f)
+       Field *f
+       CODE:
+       RETVAL = (char *)F_NAME(f);
+       OUTPUT:
+       RETVAL
+
+UV
+type(f)
+       Field *f
+       CODE:
+       RETVAL = F_TYPE(f);
+       OUTPUT:
+       RETVAL
+
+mp *
+zero(f)
+       Field *f
+       CODE:
+       RETVAL = MP_COPY(f->zero);
+       OUTPUT:
+       RETVAL
+
+mp *
+one(f)
+       Field *f
+       CODE:
+       RETVAL = MP_COPY(f->one);
+       OUTPUT:
+       RETVAL
+
+mp *
+m(f)
+       Field *f
+       CODE:
+       RETVAL = MP_COPY(f->m);
+       OUTPUT:
+       RETVAL
+
+UV
+nbits(f)
+       Field *f
+       CODE:
+       RETVAL = f->nbits;
+       OUTPUT:
+       RETVAL
+
+UV
+noctets(f)
+       Field *f
+       CODE:
+       RETVAL = f->noctets;
+       OUTPUT:
+       RETVAL
+
+mp *
+rand(f, r = &rand_global)
+       Field *f
+       grand *r
+       CODE:
+       RETVAL = F_RAND(f, MP_NEW, r);
+       OUTPUT:
+       RETVAL
+
+bool
+samep(f, ff)
+       Field *f
+       Field *ff
+       CODE:
+       RETVAL = F_SAMEP(f, ff);
+       OUTPUT:
+       RETVAL
+
+mp *
+in(f, x)
+       Field *f
+       mp *x
+       CODE:
+       RETVAL = F_IN(f, MP_NEW, x);
+       OUTPUT:
+       RETVAL
+
+mp *
+out(f, x)
+       Field *f
+       mp *x
+       CODE:
+       RETVAL = F_OUT(f, MP_NEW, x);
+       OUTPUT:
+       RETVAL
+
+bool
+zerop(f, x)
+       Field *f
+       mp *x
+       CODE:
+       RETVAL = F_ZEROP(f, x);
+       OUTPUT:
+       RETVAL
+
+mp *
+neg(f, x)
+       Field *f
+       mp *x
+       CODE:
+       RETVAL = F_NEG(f, MP_NEW, x);
+       OUTPUT:
+       RETVAL
+
+mp *
+add(f, x, y)
+       Field *f
+       mp *x
+       mp *y
+       CODE:
+       RETVAL = F_ADD(f, MP_NEW, x, y);
+       OUTPUT:
+       RETVAL
+
+mp *
+sub(f, x, y)
+       Field *f
+       mp *x
+       mp *y
+       CODE:
+       RETVAL = F_SUB(f, MP_NEW, x, y);
+       OUTPUT:
+       RETVAL
+
+mp *
+mul(f, x, y)
+       Field *f
+       mp *x
+       mp *y
+       CODE:
+       RETVAL = F_MUL(f, MP_NEW, x, y);
+       OUTPUT:
+       RETVAL
+
+mp *
+sqr(f, x)
+       Field *f
+       mp *x
+       CODE:
+       RETVAL = F_SQR(f, MP_NEW, x);
+       OUTPUT:
+       RETVAL
+
+mp *
+inv(f, x)
+       Field *f
+       mp *x
+       CODE:
+       RETVAL = F_INV(f, MP_NEW, x);
+       OUTPUT:
+       RETVAL
+
+mp *
+reduce(f, x)
+       Field *f
+       mp *x
+       CODE:
+       RETVAL = F_REDUCE(f, MP_NEW, x);
+       OUTPUT:
+       RETVAL
+
+mp *
+sqrt(f, x)
+       Field *f
+       mp *x
+       CODE:
+       RETVAL = F_SQRT(f, MP_NEW, x);
+       OUTPUT:
+       RETVAL
+
+mp *
+quadsolve(f, x)
+       Field *f
+       mp *x
+       CODE:
+       if (F_TYPE(f) != FTY_BINARY)
+         croak("quadsolve only works on binary fields");
+       RETVAL = F_QUADSOLVE(f, MP_NEW, x);
+       OUTPUT:
+       RETVAL
+
+mp *
+dbl(f, x)
+       Field *f
+       mp *x
+       CODE:
+       if (F_TYPE(f) != FTY_PRIME)
+         croak("dbl only works on prime fields");
+       RETVAL = F_DBL(f, MP_NEW, x);
+       OUTPUT:
+       RETVAL
+
+mp *
+tpl(f, x)
+       Field *f
+       mp *x
+       CODE:
+       if (F_TYPE(f) != FTY_PRIME)
+         croak("tpl only works on prime fields");
+       RETVAL = F_TPL(f, MP_NEW, x);
+       OUTPUT:
+       RETVAL
+
+mp *
+qdl(f, x)
+       Field *f
+       mp *x
+       CODE:
+       if (F_TYPE(f) != FTY_PRIME)
+         croak("qdl only works on prime fields");
+       RETVAL = F_QDL(f, MP_NEW, x);
+       OUTPUT:
+       RETVAL
+
+mp *
+hlv(f, x)
+       Field *f
+       mp *x
+       CODE:
+       if (F_TYPE(f) != FTY_PRIME)
+         croak("hlv only works on prime fields");
+       RETVAL = F_HLV(f, MP_NEW, x);
+       OUTPUT:
+       RETVAL
+