chiark - git - mdw - catacomb-perl/blob - ec.xs

   1 # ---?---
   2 #
   3 # $Id$
   4 #
   5 # Elliptic curves
   6 #
   7 # (c) 2001 Straylight/Edgeware
   8 #
   9
  10 #----- Licensing notice -----------------------------------------------------
  11 #
  12 # This file is part of the Perl interface to Catacomb.
  13 #
  14 # Catacomb/Perl is free software; you can redistribute it and/or modify
  15 # it under the terms of the GNU General Public License as published by
  16 # the Free Software Foundation; either version 2 of the License, or
  17 # (at your option) any later version.
  18 #
  19 # Catacomb/Perl is distributed in the hope that it will be useful,
  20 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 # GNU General Public License for more details.
  23 #
  24 # You should have received a copy of the GNU General Public License
  25 # along with Catacomb/Perl; if not, write to the Free Software Foundation,
  26 # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27
  28 MODULE = Catacomb PACKAGE = Catacomb::EC::Point PREFIX = ec_
  29
  30 EC_Point *
  31 new(x = 0, y = 0, z = 0)
  32         mp *x
  33         mp *y
  34         mp *z
  35         CODE:
  36         RETVAL = CREATE(EC_Point);
  37         EC_CREATE(RETVAL);
  38         if (x && y) {
  39           RETVAL->x = MP_COPY(x);
  40           RETVAL->y = MP_COPY(y);
  41           if (z)
  42             RETVAL->z = MP_COPY(z);
  43         }
  44         OUTPUT:
  45         RETVAL
  46
  47 bool
  48 atinfp(p)
  49         EC_Point *p
  50         CODE:
  51         RETVAL = EC_ATINF(p);
  52         OUTPUT:
  53         RETVAL
  54
  55 mp *
  56 x(p)
  57         EC_Point *p
  58         CODE:
  59         RETVAL = p->x ? MP_COPY(p->x) : 0;
  60         OUTPUT:
  61         RETVAL
  62
  63 mp *
  64 y(p)
  65         EC_Point *p
  66         CODE:
  67         RETVAL = p->y ? MP_COPY(p->y) : 0;
  68         OUTPUT:
  69         RETVAL
  70
  71 mp *
  72 z(p)
  73         EC_Point *p
  74         CODE:
  75         RETVAL = p->z ? MP_COPY(p->z) : 0;
  76         OUTPUT:
  77         RETVAL
  78
  79 SV *
  80 DESTROY(p)
  81         EC_Point *p
  82         CODE:
  83         EC_DESTROY(p);
  84         DESTROY(p);
  85         XSRETURN_YES;
  86
  87 MODULE = Catacomb PACKAGE = Catacomb::EC::Curve PREFIX = ec_
  88
  89 EC_Curve *
  90 ec_prime(me, f, a, b)
  91         SV *me
  92         Field *f
  93         mp *a
  94         mp *b
  95         C_ARGS:
  96         f, a, b
  97
  98 EC_Curve *
  99 ec_primeproj(me, f, a, b)
 100         SV *me
 101         Field *f
 102         mp *a
 103         mp *b
 104         C_ARGS:
 105         f, a, b
 106
 107 EC_Curve *
 108 ec_bin(me, f, a, b)
 109         SV *me
 110         Field *f
 111         gf *a
 112         gf *b
 113         C_ARGS:
 114         f, a, b
 115
 116 EC_Curve *
 117 ec_binproj(me, f, a, b)
 118         SV *me
 119         Field *f
 120         gf *a
 121         gf *b
 122         C_ARGS:
 123         f, a, b
 124
 125 char *
 126 name(c)
 127         EC_Curve *c
 128         CODE:
 129         RETVAL = (char *)EC_NAME(c);
 130         OUTPUT:
 131         RETVAL
 132
 133 bool
 134 ec_samep(me, c)
 135         EC_Curve *me
 136         EC_Curve *c
 137
 138 EC_Point *
 139 find(c, x)
 140         EC_Curve *c
 141         mp *x
 142         CODE:
 143         RETVAL = CREATE(EC_Point);
 144         if (!ec_find(c, RETVAL, x)) {
 145           DESTROY(RETVAL);
 146           RETVAL = 0;
 147         }
 148         OUTPUT:
 149         RETVAL
 150
 151 EC_Point *
 152 rand(c, r = &rand_global)
 153         EC_Curve *c
 154         grand *r
 155         CODE:
 156         RETVAL = CREATE(EC_Point);
 157         ec_rand(c, RETVAL, r);
 158         OUTPUT:
 159         RETVAL
 160
 161 EC_Point *
 162 neg(c, p)
 163         EC_Curve *c
 164         EC_Point *p
 165         CODE:
 166         RETVAL = CREATE(EC_Point);
 167         EC_CREATE(RETVAL);
 168         ec_neg(c, RETVAL, p);
 169         OUTPUT:
 170         RETVAL
 171
 172 EC_Point *
 173 add(c, p, q)
 174         EC_Curve *c
 175         EC_Point *p
 176         EC_Point *q
 177         CODE:
 178         RETVAL = CREATE(EC_Point);
 179         EC_CREATE(RETVAL);
 180         ec_add(c, RETVAL, p, q);
 181         OUTPUT:
 182         RETVAL
 183
 184 EC_Point *
 185 sub(c, p, q)
 186         EC_Curve *c
 187         EC_Point *p
 188         EC_Point *q
 189         CODE:
 190         RETVAL = CREATE(EC_Point);
 191         EC_CREATE(RETVAL);
 192         ec_sub(c, RETVAL, p, q);
 193         OUTPUT:
 194         RETVAL
 195
 196 EC_Point *
 197 dbl(c, p)
 198         EC_Curve *c
 199         EC_Point *p
 200         CODE:
 201         RETVAL = CREATE(EC_Point);
 202         EC_CREATE(RETVAL);
 203         ec_dbl(c, RETVAL, p);
 204         OUTPUT:
 205         RETVAL
 206
 207 bool
 208 ec_check(c, p)
 209         EC_Curve *c
 210         EC_Point *p
 211
 212 EC_Point *
 213 mul(c, p, x)
 214         EC_Curve *c
 215         EC_Point *p
 216         mp *x
 217         CODE:
 218         RETVAL = CREATE(EC_Point);
 219         EC_CREATE(RETVAL);
 220         ec_mul(c, RETVAL, p, x);
 221         OUTPUT:
 222         RETVAL
 223
 224 EC_Point *
 225 mmul(c, ...)
 226         EC_Curve *c
 227         PREINIT:
 228         ec_mulfactor *v;
 229         size_t i, j, n;
 230         CODE:
 231         if (items < 3 || !(items & 1)) {
 232           croak("Usage: Catacomb::EC::Curve::mmul"
 233                 "(c, p_0, x_0, p_1, x_1, ...");
 234         }
 235         n = (items - 1)/2;
 236         v = xmalloc(n * sizeof(mp_expfactor));
 237         for (i = 1, j = 0; i < items; i += 2, j++) {
 238           v[j].base = *(ec *)ptrfromsv(ST(i), "Catacomb::EC::Point", "p_i");
 239           v[j].exp = mp_fromsv(ST(i + 1), "x_i", "Catacomb::MP", 0, 0);
 240         }
 241         RETVAL = CREATE(RETVAL);
 242         EC_CREATE(RETVAL);
 243         ec_mmul(c, RETVAL, v, n);
 244         xfree(v);
 245         OUTPUT:
 246         RETVAL
 247
 248 EC_Point *
 249 in(c, p)
 250         EC_Curve *c
 251         EC_Point *p
 252         CODE:
 253         RETVAL = CREATE(EC_Point);
 254         EC_CREATE(RETVAL);
 255         EC_IN(c, RETVAL, p);
 256         OUTPUT:
 257         RETVAL
 258
 259 EC_Point *
 260 out(c, p)
 261         EC_Curve *c
 262         EC_Point *p
 263         CODE:
 264         RETVAL = CREATE(EC_Point);
 265         EC_CREATE(RETVAL);
 266         EC_OUT(c, RETVAL, p);
 267         OUTPUT:
 268         RETVAL
 269
 270 EC_Point *
 271 fix(c, p)
 272         EC_Curve *c
 273         EC_Point *p
 274         CODE:
 275         RETVAL = CREATE(EC_Point);
 276         EC_CREATE(RETVAL);
 277         EC_FIX(c, RETVAL, p);
 278         OUTPUT:
 279         RETVAL
 280
 281 EC_Point *
 282 ifind(c, x)
 283         EC_Curve *c
 284         mp *x
 285         CODE:
 286         RETVAL = CREATE(EC_Point);
 287         if (!EC_FIND(c, RETVAL, x)) {
 288           DESTROY(RETVAL);
 289           RETVAL = 0;
 290         }
 291         OUTPUT:
 292         RETVAL
 293
 294 EC_Point *
 295 ineg(c, p)
 296         EC_Curve *c
 297         EC_Point *p
 298         CODE:
 299         RETVAL = CREATE(EC_Point);
 300         EC_CREATE(RETVAL);
 301         EC_NEG(c, RETVAL, p);
 302         OUTPUT:
 303         RETVAL
 304
 305 EC_Point *
 306 iadd(c, p, q)
 307         EC_Curve *c
 308         EC_Point *p
 309         EC_Point *q
 310         CODE:
 311         RETVAL = CREATE(EC_Point);
 312         EC_CREATE(RETVAL);
 313         EC_ADD(c, RETVAL, p, q);
 314         OUTPUT:
 315         RETVAL
 316
 317 EC_Point *
 318 isub(c, p, q)
 319         EC_Curve *c
 320         EC_Point *p
 321         EC_Point *q
 322         CODE:
 323         RETVAL = CREATE(EC_Point);
 324         EC_CREATE(RETVAL);
 325         EC_SUB(c, RETVAL, p, q);
 326         OUTPUT:
 327         RETVAL
 328
 329 EC_Point *
 330 idbl(c, p)
 331         EC_Curve *c
 332         EC_Point *p
 333         CODE:
 334         RETVAL = CREATE(EC_Point);
 335         EC_CREATE(RETVAL);
 336         EC_DBL(c, RETVAL, p);
 337         OUTPUT:
 338         RETVAL
 339
 340 bool
 341 icheck(c, p)
 342         EC_Curve *c
 343         EC_Point *p
 344         CODE:
 345         RETVAL = EC_CHECK(c, p);
 346         OUTPUT:
 347         RETVAL
 348
 349 EC_Point *
 350 imul(c, p, x)
 351         EC_Curve *c
 352         EC_Point *p
 353         mp *x
 354         CODE:
 355         RETVAL = CREATE(EC_Point);
 356         EC_CREATE(RETVAL);
 357         ec_imul(c, RETVAL, p, x);
 358         OUTPUT:
 359         RETVAL
 360
 361 EC_Point *
 362 immul(c, ...)
 363         EC_Curve *c
 364         PREINIT:
 365         ec_mulfactor *v;
 366         size_t i, j, n;
 367         CODE:
 368         if (items < 3 || !(items & 1)) {
 369           croak("Usage: Catacomb::EC::Curve::immul"
 370                 "(c, p_0, x_0, p_1, x_1, ...");
 371         }
 372         n = (items - 1)/2;
 373         v = xmalloc(n * sizeof(mp_expfactor));
 374         for (i = 1, j = 0; i < items; i += 2, j++) {
 375           v[j].base = *(ec *)ptrfromsv(ST(i), "Catacomb::EC::Point", "p_i");
 376           v[j].exp = mp_fromsv(ST(i + 1), "x_i", "Catacomb::MP", 0, 0);
 377         }
 378         RETVAL = CREATE(RETVAL);
 379         EC_CREATE(RETVAL);
 380         ec_mmul(c, RETVAL, v, n);
 381         xfree(v);
 382         OUTPUT:
 383         RETVAL
 384
 385 void
 386 getinfo(me, p)
 387         char *p
 388         PREINIT:
 389         ec_info i;
 390         const char *e;
 391         EC_Point *pt;
 392         PPCODE:
 393         if ((e = ec_getinfo(&i, p)) != 0)
 394           croak("bad curve spec: %s", e);
 395         pt = CREATE(EC_Point);
 396         *pt = i.g;
 397         XPUSHs(RET(i.c, "Catacomb::EC::Curve"));
 398         XPUSHs(RET(pt, "Catacomb::EC::Point"));
 399         XPUSHs(RET(i.r, "Catacomb::MP"));
 400         XPUSHs(RET(i.h, "Catacomb::MP"));
 401