chiark - git - mdw - catacomb-python/blob - group.c

   1 /* -*-c-*-
   2  *
   3  * Abstract group inteface
   4  *
   5  * (c) 2004 Straylight/Edgeware
   6  */
   7
   8 /*----- Licensing notice --------------------------------------------------*
   9  *
  10  * This file is part of the Python interface to Catacomb.
  11  *
  12  * Catacomb/Python is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * Catacomb/Python is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with Catacomb/Python; if not, write to the Free Software Foundation,
  24  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25  */
  26
  27 /*----- Header files ------------------------------------------------------*/
  28
  29 #include "catacomb-python.h"
  30
  31 /*----- DH and binary group infos -----------------------------------------*/
  32
  33 static PyTypeObject *fginfo_pytype, *dhinfo_pytype, *bindhinfo_pytype;
  34
  35 typedef struct fginfo_pyobj {
  36   PyObject_HEAD
  37   gprime_param dp;
  38 } fginfo_pyobj;
  39
  40 #define FGINFO_DP(fg) (&((fginfo_pyobj *)(fg))->dp)
  41
  42 static PyObject *fginfo_pywrap(gprime_param *dp, PyTypeObject *ty)
  43 {
  44   fginfo_pyobj *z = PyObject_New(fginfo_pyobj, ty);
  45   z->dp = *dp;
  46   return ((PyObject *)z);
  47 }
  48
  49 static PyObject *fginfo_pynew(PyTypeObject *ty,
  50                               PyObject *arg, PyObject *kw)
  51 {
  52   static const char *const kwlist[] = { "p", "r", "g", 0 };
  53   gprime_param dp = { 0 };
  54   fginfo_pyobj *z = 0;
  55
  56   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&O&:new", KWLIST,
  57                                    convmp, &dp.p,
  58                                    convmp, &dp.q,
  59                                    convmp, &dp.g))
  60     goto end;
  61   z = PyObject_New(fginfo_pyobj, ty);
  62   z->dp = dp;
  63   return ((PyObject *)z);
  64 end:
  65   mp_drop(dp.p);
  66   mp_drop(dp.q);
  67   mp_drop(dp.g);
  68   return (0);
  69 }
  70
  71 static PyObject *figet_r(PyObject *me, void *hunoz)
  72   { return mp_pywrap(MP_COPY(FGINFO_DP(me)->q)); }
  73
  74 static PyObject *diget_p(PyObject *me, void *hunoz)
  75   { return mp_pywrap(MP_COPY(FGINFO_DP(me)->p)); }
  76
  77 static PyObject *diget_g(PyObject *me, void *hunoz)
  78   { return mp_pywrap(MP_COPY(FGINFO_DP(me)->g)); }
  79
  80 static PyObject *biget_p(PyObject *me, void *hunoz)
  81   { return gf_pywrap(MP_COPY(FGINFO_DP(me)->p)); }
  82
  83 static PyObject *biget_m(PyObject *me, void *hunoz)
  84   { return PyInt_FromLong(mp_octets(FGINFO_DP(me)->p) - 1); }
  85
  86 static PyObject *biget_g(PyObject *me, void *hunoz)
  87   { return gf_pywrap(MP_COPY(FGINFO_DP(me)->g)); }
  88
  89 static void fginfo_pydealloc(PyObject *me)
  90 {
  91   mp_drop(FGINFO_DP(me)->p);
  92   mp_drop(FGINFO_DP(me)->q);
  93   mp_drop(FGINFO_DP(me)->g);
  94   FREEOBJ(me);
  95 }
  96
  97 static PyObject *dimeth_generate(PyObject *me, PyObject *arg, PyObject *kw)
  98 {
  99   dh_param dp;
 100   unsigned ql = 0, pl;
 101   unsigned steps = 0;
 102   grand *r = &rand_global;
 103   struct excinfo exc = EXCINFO_INIT;
 104   pypgev evt = { { 0 } };
 105   static const char *const kwlist[] =
 106     { "pbits", "qbits", "event", "rng", "nsteps", 0 };
 107   PyObject *rc = 0;
 108
 109   evt.exc = &exc;
 110   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&O&O&O&:generate", KWLIST,
 111                                    convuint, &pl, convuint, &ql,
 112                                    convpgev, &evt, convgrand, &r,
 113                                    convuint, &steps))
 114     goto end;
 115   if (dh_gen(&dp, ql, pl, steps, r, evt.ev.proc, evt.ev.ctx))
 116     PGENERR(&exc);
 117   rc = fginfo_pywrap(&dp, dhinfo_pytype);
 118 end:
 119   droppgev(&evt);
 120   return (rc);
 121 }
 122
 123 static PyObject *dimeth_genlimlee(PyObject *me, PyObject *arg, PyObject *kw)
 124 {
 125   dh_param dp;
 126   unsigned ql, pl;
 127   unsigned steps = 0;
 128   grand *r = &rand_global;
 129   struct excinfo exc = EXCINFO_INIT;
 130   pypgev oe = { { 0 } }, ie = { { 0 } };
 131   int subgroupp = 1;
 132   unsigned f = 0;
 133   static const char *const kwlist[] = {
 134     "pbits", "qbits", "event", "ievent",
 135     "rng", "nsteps", "subgroupp", 0
 136   };
 137   size_t i, nf;
 138   mp **v = 0;
 139   PyObject *rc = 0, *vec = 0;
 140
 141   oe.exc = ie.exc = &exc;
 142   if (!PyArg_ParseTupleAndKeywords(arg, kw,
 143                                    "O&O&|O&O&O&O&O&:genlimlee", KWLIST,
 144                                    convuint, &pl, convuint, &ql,
 145                                    convpgev, &oe, convpgev, &ie,
 146                                    convgrand, &r, convuint, &steps,
 147                                    convbool, &subgroupp))
 148     goto end;
 149   if (subgroupp) f |= DH_SUBGROUP;
 150   if (dh_limlee(&dp, ql, pl, f, steps, r,
 151                 oe.ev.proc, oe.ev.ctx, ie.ev.proc, ie.ev.ctx, &nf, &v))
 152     PGENERR(&exc);
 153   vec = PyList_New(nf);
 154   for (i = 0; i < nf; i++)
 155     PyList_SET_ITEM(vec, i, mp_pywrap(v[i]));
 156   xfree(v);
 157   rc = Py_BuildValue("(NN)", fginfo_pywrap(&dp, dhinfo_pytype), vec);
 158 end:
 159   droppgev(&oe); droppgev(&ie);
 160   return (rc);
 161 }
 162
 163 static PyObject *dimeth_genkcdsa(PyObject *me, PyObject *arg, PyObject *kw)
 164 {
 165   dh_param dp;
 166   unsigned ql, pl;
 167   unsigned steps = 0;
 168   grand *r = &rand_global;
 169   struct excinfo exc = EXCINFO_INIT;
 170   pypgev evt = { { 0 } };
 171   static const char *const kwlist[] =
 172     { "pbits", "qbits", "event", "rng", "nsteps", 0 };
 173   mp *v = MP_NEW;
 174   PyObject *rc = 0;
 175
 176   evt.exc = &exc;
 177   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&|O&O&O&:genkcdsa", KWLIST,
 178                                    convuint, &pl, convuint, &ql,
 179                                    convpgev, &evt, convgrand, &r,
 180                                    convuint, &steps))
 181     goto end;
 182   if (dh_kcdsagen(&dp, ql, pl, 0, steps, r, evt.ev.proc, evt.ev.ctx))
 183     PGENERR(&exc);
 184   mp_div(&v, 0, dp.p, dp.q);
 185   v = mp_lsr(v, v, 1);
 186   rc = Py_BuildValue("(NN)", fginfo_pywrap(&dp, dhinfo_pytype),
 187                      mp_pywrap(v));
 188 end:
 189   droppgev(&evt);
 190   return (rc);
 191 }
 192
 193 static PyObject *dimeth_gendsa(PyObject *me, PyObject *arg, PyObject *kw)
 194 {
 195   dsa_param dp;
 196   unsigned ql, pl;
 197   unsigned steps = 0;
 198   dsa_seed ds;
 199   char *k;
 200   Py_ssize_t ksz;
 201   struct excinfo exc = EXCINFO_INIT;
 202   pypgev evt = { { 0 } };
 203   static const char *const kwlist[] =
 204     { "pbits", "qbits", "seed", "event", "nsteps", 0 };
 205   PyObject *rc = 0;
 206
 207   evt.exc = &exc;
 208   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&s#|O&O&:gendsa", KWLIST,
 209                                    convuint, &pl, convuint, &ql,
 210                                    &k, &ksz, convpgev, &evt,
 211                                    convuint, &steps))
 212     goto end;
 213   if (dsa_gen(&dp, ql, pl, steps, k, ksz, &ds, evt.ev.proc, evt.ev.ctx))
 214     PGENERR(&exc);
 215   rc = Py_BuildValue("(NNl)", fginfo_pywrap(&dp, dhinfo_pytype),
 216                      bytestring_pywrap(ds.p, ds.sz), (long)ds.count);
 217   xfree(ds.p);
 218 end:
 219   droppgev(&evt);
 220   return (rc);
 221 }
 222
 223 static int npgroups = -1, nbingroups = -1;
 224
 225 static PyObject *namedgroups(const pentry *pp, int *ne)
 226 {
 227   int i, j;
 228   const char *p;
 229   PyObject *d, *c;
 230
 231   d = PyDict_New();
 232   for (i = 0; pp[i].name; i++) {
 233     p = pp[i].name;
 234     for (j = 0; j < i; j++) {
 235       if (pp[i].data == pp[j].data) {
 236         c = PyDict_GetItemString(d, (/*unconst*/ char *)pp[j].name);
 237         Py_INCREF(c);
 238         goto found;
 239       }
 240     }
 241     c = PyInt_FromLong(i);
 242   found:
 243     PyDict_SetItemString(d, (/*unconst*/ char *)p, c);
 244     Py_DECREF(c);
 245   }
 246   *ne = i;
 247   return (d);
 248 }
 249
 250 static PyObject *meth__groupn(PyObject *me, PyObject *arg,
 251                               PyTypeObject *ty, const pentry *pp, int ne)
 252 {
 253   int i;
 254   gprime_param gp;
 255   PyObject *rc = 0;
 256
 257   if (!PyArg_ParseTuple(arg, "i:_groupn", &i)) goto end;
 258   if (i < 0 || i >= ne) VALERR("group index out of range");
 259   dh_infofromdata(&gp, pp[i].data);
 260   rc = fginfo_pywrap(&gp, ty);
 261 end:
 262   return (rc);
 263 }
 264
 265 static PyObject *dimeth__groupn(PyObject *me, PyObject *arg)
 266   { return (meth__groupn(me, arg, dhinfo_pytype, ptab, npgroups)); }
 267
 268 static PyObject *bimeth__groupn(PyObject *me, PyObject *arg)
 269   { return (meth__groupn(me, arg, bindhinfo_pytype, bintab, nbingroups)); }
 270
 271 static PyObject *meth__parse(PyObject *me, PyObject *arg, PyTypeObject *ty,
 272                              int (*parse)(qd_parse *, gprime_param *))
 273 {
 274   qd_parse qd;
 275   char *p;
 276   gprime_param gp;
 277   PyObject *rc = 0;
 278
 279   if (!PyArg_ParseTuple(arg, "s:parse", &p)) goto end;
 280   qd.p = p; qd.e = 0;
 281   if (parse(&qd, &gp)) VALERR(qd.e);
 282   rc = fginfo_pywrap(&gp, ty);
 283 end:
 284   return (rc);
 285 }
 286
 287 static PyObject *dimeth_parse(PyObject *me, PyObject *arg)
 288   { return (meth__parse(me, arg, dhinfo_pytype, dh_parse)); }
 289
 290 static PyObject *bimeth_parse(PyObject *me, PyObject *arg)
 291   { return (meth__parse(me, arg, bindhinfo_pytype, dhbin_parse)); }
 292
 293 static const PyGetSetDef fginfo_pygetset[] = {
 294 #define GETSETNAME(op, name) fi##op##_##name
 295   GET   (r,             "I.r -> group order")
 296 #undef GETSETNAME
 297   { 0 }
 298 };
 299
 300 static const PyGetSetDef dhinfo_pygetset[] = {
 301 #define GETSETNAME(op, name) di##op##_##name
 302   GET   (p,             "I.p -> prime")
 303   GET   (g,             "I.g -> generator")
 304 #undef GETSETNAME
 305   { 0 }
 306 };
 307
 308 static const PyMethodDef dhinfo_pymethods[] = {
 309 #define METHNAME(name) dimeth_##name
 310   SMTH  (parse,         "parse(STR) -> D, REST")
 311   SMTH  (_groupn,       0)
 312   KWSMTH(generate,
 313        "generate(PBITS, [qbits = 0], [event = pgen_nullev],\n"
 314        "         [rng = rand], [nsteps = 0]) -> D")
 315   KWSMTH(genlimlee,
 316        "genlimlee(PBITS, QBITS, [event = pgen_nullev], "
 317                                                   "[ievent = pgen_nullev],\n"
 318        "          [rng = rand], [nsteps = 0], [subgroupp = True]) "
 319                                                           "-> (D, [Q, ...])")
 320   KWSMTH(gendsa,
 321        "gendsa(PBITS, QBITS, SEED, [event = pgen_nullev], [nsteps = 0])\n"
 322        "  -> (D, SEED, COUNT)")
 323   KWSMTH(genkcdsa,
 324        "gendsa(PBITS, QBITS, [event = pgen_nullev], "
 325                                               "[rng = rand], [nsteps = 0])\n"
 326        "  -> (D, V)")
 327 #undef METHNAME
 328   { 0 }
 329 };
 330
 331 static const PyGetSetDef bindhinfo_pygetset[] = {
 332 #define GETSETNAME(op, name) bi##op##_##name
 333   GET   (p,             "I.p -> irreducible polynomial")
 334   GET   (m,             "I.m -> degree of polynomial")
 335   GET   (g,             "I.g -> generator")
 336 #undef GETSETNAME
 337   { 0 }
 338 };
 339
 340 static const PyMethodDef bindhinfo_pymethods[] = {
 341 #define METHNAME(name) bimeth_##name
 342   SMTH  (parse,         "parse(STR) -> D, REST")
 343   SMTH  (_groupn,       0)
 344 #undef METHNAME
 345   { 0 }
 346 };
 347
 348 static PyTypeObject fginfo_pytype_skel = {
 349   PyObject_HEAD_INIT(0) 0,              /* Header */
 350   "FGInfo",                             /* @tp_name@ */
 351   sizeof(fginfo_pyobj),                 /* @tp_basicsize@ */
 352   0,                                    /* @tp_itemsize@ */
 353
 354   fginfo_pydealloc,                     /* @tp_dealloc@ */
 355   0,                                    /* @tp_print@ */
 356   0,                                    /* @tp_getattr@ */
 357   0,                                    /* @tp_setattr@ */
 358   0,                                    /* @tp_compare@ */
 359   0,                                    /* @tp_repr@ */
 360   0,                                    /* @tp_as_number@ */
 361   0,                                    /* @tp_as_sequence@ */
 362   0,                                    /* @tp_as_mapping@ */
 363   0,                                    /* @tp_hash@ */
 364   0,                                    /* @tp_call@ */
 365   0,                                    /* @tp_str@ */
 366   0,                                    /* @tp_getattro@ */
 367   0,                                    /* @tp_setattro@ */
 368   0,                                    /* @tp_as_buffer@ */
 369   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 370     Py_TPFLAGS_BASETYPE,
 371
 372   /* @tp_doc@ */
 373   "Abstract base class for field-group information objects.",
 374
 375   0,                                    /* @tp_traverse@ */
 376   0,                                    /* @tp_clear@ */
 377   0,                                    /* @tp_richcompare@ */
 378   0,                                    /* @tp_weaklistoffset@ */
 379   0,                                    /* @tp_iter@ */
 380   0,                                    /* @tp_iternext@ */
 381   0,                                    /* @tp_methods@ */
 382   0,                                    /* @tp_members@ */
 383   PYGETSET(fginfo),                     /* @tp_getset@ */
 384   0,                                    /* @tp_base@ */
 385   0,                                    /* @tp_dict@ */
 386   0,                                    /* @tp_descr_get@ */
 387   0,                                    /* @tp_descr_set@ */
 388   0,                                    /* @tp_dictoffset@ */
 389   0,                                    /* @tp_init@ */
 390   PyType_GenericAlloc,                  /* @tp_alloc@ */
 391   abstract_pynew,                       /* @tp_new@ */
 392   0,                                    /* @tp_free@ */
 393   0                                     /* @tp_is_gc@ */
 394 };
 395
 396 static PyTypeObject dhinfo_pytype_skel = {
 397   PyObject_HEAD_INIT(0) 0,              /* Header */
 398   "DHInfo",                             /* @tp_name@ */
 399   sizeof(fginfo_pyobj),                 /* @tp_basicsize@ */
 400   0,                                    /* @tp_itemsize@ */
 401
 402   fginfo_pydealloc,                     /* @tp_dealloc@ */
 403   0,                                    /* @tp_print@ */
 404   0,                                    /* @tp_getattr@ */
 405   0,                                    /* @tp_setattr@ */
 406   0,                                    /* @tp_compare@ */
 407   0,                                    /* @tp_repr@ */
 408   0,                                    /* @tp_as_number@ */
 409   0,                                    /* @tp_as_sequence@ */
 410   0,                                    /* @tp_as_mapping@ */
 411   0,                                    /* @tp_hash@ */
 412   0,                                    /* @tp_call@ */
 413   0,                                    /* @tp_str@ */
 414   0,                                    /* @tp_getattro@ */
 415   0,                                    /* @tp_setattro@ */
 416   0,                                    /* @tp_as_buffer@ */
 417   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 418     Py_TPFLAGS_BASETYPE,
 419
 420   /* @tp_doc@ */
 421   "DHInfo(P, R, G): standard (integer) Diffie-Hellman group information.",
 422
 423   0,                                    /* @tp_traverse@ */
 424   0,                                    /* @tp_clear@ */
 425   0,                                    /* @tp_richcompare@ */
 426   0,                                    /* @tp_weaklistoffset@ */
 427   0,                                    /* @tp_iter@ */
 428   0,                                    /* @tp_iternext@ */
 429   PYMETHODS(dhinfo),                    /* @tp_methods@ */
 430   0,                                    /* @tp_members@ */
 431   PYGETSET(dhinfo),                     /* @tp_getset@ */
 432   0,                                    /* @tp_base@ */
 433   0,                                    /* @tp_dict@ */
 434   0,                                    /* @tp_descr_get@ */
 435   0,                                    /* @tp_descr_set@ */
 436   0,                                    /* @tp_dictoffset@ */
 437   0,                                    /* @tp_init@ */
 438   PyType_GenericAlloc,                  /* @tp_alloc@ */
 439   fginfo_pynew,                         /* @tp_new@ */
 440   0,                                    /* @tp_free@ */
 441   0                                     /* @tp_is_gc@ */
 442 };
 443
 444 static PyTypeObject bindhinfo_pytype_skel = {
 445   PyObject_HEAD_INIT(0) 0,              /* Header */
 446   "BinDHInfo",                          /* @tp_name@ */
 447   sizeof(fginfo_pyobj),                 /* @tp_basicsize@ */
 448   0,                                    /* @tp_itemsize@ */
 449
 450   fginfo_pydealloc,                     /* @tp_dealloc@ */
 451   0,                                    /* @tp_print@ */
 452   0,                                    /* @tp_getattr@ */
 453   0,                                    /* @tp_setattr@ */
 454   0,                                    /* @tp_compare@ */
 455   0,                                    /* @tp_repr@ */
 456   0,                                    /* @tp_as_number@ */
 457   0,                                    /* @tp_as_sequence@ */
 458   0,                                    /* @tp_as_mapping@ */
 459   0,                                    /* @tp_hash@ */
 460   0,                                    /* @tp_call@ */
 461   0,                                    /* @tp_str@ */
 462   0,                                    /* @tp_getattro@ */
 463   0,                                    /* @tp_setattro@ */
 464   0,                                    /* @tp_as_buffer@ */
 465   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 466     Py_TPFLAGS_BASETYPE,
 467
 468   /* @tp_doc@ */
 469   "BinDHInfo(P, R, G): binary-field Diffie-Hellman group information.",
 470
 471   0,                                    /* @tp_traverse@ */
 472   0,                                    /* @tp_clear@ */
 473   0,                                    /* @tp_richcompare@ */
 474   0,                                    /* @tp_weaklistoffset@ */
 475   0,                                    /* @tp_iter@ */
 476   0,                                    /* @tp_iternext@ */
 477   PYMETHODS(bindhinfo),                 /* @tp_methods@ */
 478   0,                                    /* @tp_members@ */
 479   PYGETSET(bindhinfo),                  /* @tp_getset@ */
 480   0,                                    /* @tp_base@ */
 481   0,                                    /* @tp_dict@ */
 482   0,                                    /* @tp_descr_get@ */
 483   0,                                    /* @tp_descr_set@ */
 484   0,                                    /* @tp_dictoffset@ */
 485   0,                                    /* @tp_init@ */
 486   PyType_GenericAlloc,                  /* @tp_alloc@ */
 487   fginfo_pynew,                         /* @tp_new@ */
 488   0,                                    /* @tp_free@ */
 489   0                                     /* @tp_is_gc@ */
 490 };
 491
 492 /*----- General utilities -------------------------------------------------*/
 493
 494 PyTypeObject *ge_pytype, *group_pytype;
 495 static PyTypeObject *primegroup_pytype, *bingroup_pytype, *ecgroup_pytype;
 496
 497 group *group_copy(group *g)
 498 {
 499   if (STRCMP(G_NAME(g), ==, "prime")) {
 500     gctx_prime *gc = (gctx_prime *)g;
 501     gprime_param gp;
 502     gp.g = G_TOINT(g, MP_NEW, g->g);
 503     gp.p = gc->mm.m;
 504     gp.q = gc->g.r;
 505     g = group_prime(&gp);
 506     MP_DROP(gp.g);
 507   } else if (STRCMP(G_NAME(g), ==, "bin")) {
 508     gctx_bin *gc = (gctx_bin *)g;
 509     gbin_param gb;
 510     gb.g = G_TOINT(g, MP_NEW, g->g);
 511     gb.p = gc->r.p;
 512     gb.q = gc->g.r;
 513     g = group_binary(&gb);
 514     MP_DROP(gb.g);
 515   } else if (STRCMP(G_NAME(g), ==, "ec")) {
 516     gctx_ec *gc = (gctx_ec *)g;
 517     ec_info ei;
 518     if ((ei.c = eccurve_copy(gc->ei.c)) == 0)
 519       return (0);
 520     EC_CREATE(&ei.g);
 521     EC_COPY(&ei.g, &gc->ei.g);
 522     ei.r = MP_COPY(gc->ei.r);
 523     ei.h = MP_COPY(gc->ei.h);
 524     g = group_ec(&ei);
 525   } else
 526     g = 0;
 527   return (g);
 528 }
 529
 530 PyObject *ge_pywrap(PyObject *gobj, ge *x)
 531 {
 532   ge_pyobj *z = PyObject_New(ge_pyobj, (PyTypeObject *)gobj);
 533   z->x = x;
 534   z->g = GROUP_G(gobj);
 535   Py_INCREF(gobj);
 536   return ((PyObject *)z);
 537 }
 538
 539 static PyObject *ge_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
 540 {
 541   static const char *const kwlist[] = { "x", 0 };
 542   PyObject *x;
 543   group *g;
 544   ec p = EC_INIT;
 545   mp *y = 0;
 546   ge *xx = 0;
 547   mptext_stringctx sc;
 548
 549   g = GROUP_G(ty);
 550   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O:new", KWLIST, &x)) goto end;
 551   xx = G_CREATE(g);
 552   if (ECPT_PYCHECK(x)) {
 553     getecptout(&p, x);
 554     if (G_FROMEC(g, xx, &p))
 555       TYERR("can't convert from elliptic curve point");
 556     EC_DESTROY(&p);
 557   } else if ((y = tomp(x)) != 0) {
 558     if (G_FROMINT(g, xx, y))
 559       TYERR("can't convert from integer");
 560     MP_DROP(y);
 561   } else if (PyString_Check(x)) {
 562     sc.buf = PyString_AS_STRING(x);
 563     sc.lim = sc.buf + PyString_GET_SIZE(x);
 564     if (G_READ(g, xx, &mptext_stringops, &sc) || sc.buf < sc.lim)
 565       VALERR("malformed group element string");
 566   } else
 567     TYERR("can't convert to group element");
 568   return (ge_pywrap((PyObject *)ty, xx));
 569 end:
 570   mp_drop(y);
 571   EC_DESTROY(&p);
 572   if (xx) G_DESTROY(g, xx);
 573   return (0);
 574 }
 575
 576 static PyObject *group_dopywrap(PyTypeObject *ty, group *g)
 577 {
 578   group_pyobj *gobj = newtype(ty, 0, g->ops->name);
 579   gobj->g = g;
 580   gobj->ty.ht_type.tp_basicsize = sizeof(ge_pyobj);
 581   gobj->ty.ht_type.tp_base = ge_pytype;
 582   Py_INCREF(group_pytype);
 583   gobj->ty.ht_type.tp_flags = (Py_TPFLAGS_DEFAULT |
 584                                Py_TPFLAGS_BASETYPE |
 585                                Py_TPFLAGS_CHECKTYPES |
 586                                Py_TPFLAGS_HEAPTYPE);
 587   gobj->ty.ht_type.tp_alloc = PyType_GenericAlloc;
 588   gobj->ty.ht_type.tp_free = 0;
 589   gobj->ty.ht_type.tp_new = ge_pynew;
 590   typeready(&gobj->ty.ht_type);
 591   return ((PyObject *)gobj);
 592 }
 593
 594 PyObject *group_pywrap(group *g)
 595 {
 596   PyTypeObject *ty;
 597
 598   if (STRCMP(G_NAME(g), ==, "prime")) ty = primegroup_pytype;
 599   else if (STRCMP(G_NAME(g), ==, "bin")) ty = bingroup_pytype;
 600   else if (STRCMP(G_NAME(g), ==, "ec")) ty = ecgroup_pytype;
 601   else abort();
 602   return (group_dopywrap(ty, g));
 603 }
 604
 605 /*----- Group elements ----------------------------------------------------*/
 606
 607 #define BINOP(name)                                                     \
 608   static PyObject *ge_py##name(PyObject *x, PyObject *y)                \
 609   {                                                                     \
 610     ge *z;                                                              \
 611     group *g;                                                           \
 612     if (!GE_PYCHECK(x) || !GE_PYCHECK(y) ||                             \
 613         (GE_G(x) != GE_G(y) && !group_samep(GE_G(x), GE_G(y))))         \
 614       RETURN_NOTIMPL;                                                   \
 615     g = GE_G(x);                                                        \
 616     z = G_CREATE(g);                                                    \
 617     g->ops->name(g, z, GE_X(x), GE_X(y));                               \
 618     return (ge_pywrap(GE_GOBJ(x), z));                                  \
 619   }
 620 BINOP(mul)
 621 BINOP(div)
 622 #undef BINOP
 623
 624 #define UNOP(name)                                                      \
 625   static PyObject *gemeth_##name(PyObject *me, PyObject *arg)           \
 626   {                                                                     \
 627     group *g;                                                           \
 628     ge *z;                                                              \
 629     if (!PyArg_ParseTuple(arg, ":" #name)) return (0);                  \
 630     g = GE_G(me);                                                       \
 631     z = G_CREATE(g);                                                    \
 632     g->ops->name(g, z, GE_X(me));                                       \
 633     return (ge_pywrap(GE_GOBJ(me), z));                                 \
 634   }
 635 UNOP(sqr)
 636 UNOP(inv)
 637 #undef UNOP
 638
 639 static PyObject *ge_pyexp(PyObject *x, PyObject *n, PyObject *m)
 640 {
 641   mp *nn;
 642   ge *z;
 643
 644   if (m != Py_None || !GE_PYCHECK(x) || (nn = getmp(n)) == 0)
 645     RETURN_NOTIMPL;
 646   z = G_CREATE(GE_G(x));
 647   G_EXP(GE_G(x), z, GE_X(x), nn);
 648   MP_DROP(nn);
 649   return (ge_pywrap(GE_GOBJ(x), z));
 650 }
 651
 652 static void ge_pydealloc(PyObject *me)
 653 {
 654   G_DESTROY(GE_G(me), GE_X(me));
 655   Py_DECREF(GE_GOBJ(me));
 656   FREEOBJ(me);
 657 }
 658
 659 static void group_pydealloc(PyObject *me)
 660 {
 661   G_DESTROYGROUP(GROUP_G(me));
 662   PyType_Type.tp_dealloc(me);
 663 }
 664
 665 static PyObject *gmexp_id(PyObject *me)
 666 {
 667   group *g = GROUP_G(me); ge *x = G_CREATE(g);
 668   G_COPY(g, x, g->i); return (ge_pywrap(me, x));
 669 }
 670
 671 static int gmexp_fill(void *pp, PyObject  *me, PyObject *x, PyObject *m)
 672 {
 673   group_expfactor *f = pp;
 674
 675   if (!GE_PYCHECK(x) || GE_G(x) != GROUP_G(me) || (f->exp = getmp(m)) == 0)
 676     return (-1);
 677   f->base = GE_X(x);
 678   return (0);
 679 }
 680
 681 static PyObject *ge_pyrichcompare(PyObject *x, PyObject *y, int op)
 682 {
 683   int b;
 684   PyObject *rc = 0;
 685
 686   if (!GE_PYCHECK(x) || !GE_PYCHECK(y) ||
 687       (GE_G(x) != GE_G(y) && !group_samep(GE_G(x), GE_G(y))))
 688     RETURN_NOTIMPL;
 689   switch (op) {
 690     case Py_EQ: b = G_EQ(GE_G(x), GE_X(x), GE_X(y)); break;
 691     case Py_NE: b = !G_EQ(GE_G(x), GE_X(x), GE_X(y)); break;
 692     default: TYERR("group elements are unordered");
 693   }
 694   rc = getbool(b);
 695 end:
 696   return (rc);
 697 }
 698
 699 static PyObject *gemeth_check(PyObject *me, PyObject *arg)
 700 {
 701   if (!PyArg_ParseTuple(arg, ":check")) goto end;
 702   if (group_check(GE_G(me), GE_X(me))) VALERR("bad group element");
 703   RETURN_OBJ(me);
 704 end:
 705   return (0);
 706 }
 707
 708 static int ge_pynonzerop(PyObject *x)
 709   { return (!G_IDENTP(GE_G(x), GE_X(x))); }
 710
 711 static PyObject *ge_pystr(PyObject *me)
 712 {
 713   dstr d = DSTR_INIT;
 714   PyObject *rc;
 715
 716   group_writedstr(GE_G(me), GE_X(me), &d);
 717   rc = PyString_FromStringAndSize(d.buf, d.len);
 718   DDESTROY(&d);
 719   return (rc);
 720 }
 721
 722 static PyObject *ge_pylong(PyObject *me)
 723 {
 724   mp *x = 0;
 725   PyObject *rc = 0;
 726
 727   if ((x = G_TOINT(GE_G(me), MP_NEW, GE_X(me))) == 0)
 728     TYERR("can't convert to integer");
 729   rc = mp_topylong(x);
 730 end:
 731   mp_drop(x);
 732   return (rc);
 733 }
 734
 735 static PyObject *ge_pyint(PyObject *me)
 736 {
 737   mp *x = 0;
 738   PyObject *rc = 0;
 739   long l;
 740
 741   if ((x = G_TOINT(GE_G(me), MP_NEW, GE_X(me))) == 0)
 742     TYERR("can't convert to integer");
 743   if (!mp_tolong_checked(x, &l, 0)) rc = PyInt_FromLong(l);
 744   else rc = mp_topylong(x);
 745 end:
 746   mp_drop(x);
 747   return (rc);
 748 }
 749
 750 static PyObject *gemeth_toint(PyObject *me, PyObject *arg)
 751 {
 752   mp *x;
 753
 754   if (!PyArg_ParseTuple(arg, ":toint")) goto end;
 755   if ((x = G_TOINT(GE_G(me), MP_NEW, GE_X(me))) == 0)
 756     TYERR("can't convert to integer");
 757   return (mp_pywrap(x));
 758 end:
 759   return (0);
 760 }
 761
 762 static PyObject *gemeth_toec(PyObject *me, PyObject *arg, PyObject *kw)
 763 {
 764   static const char *const kwlist[] = { "curve", 0 };
 765   PyTypeObject *cty = 0;
 766   PyObject *rc = 0;
 767   group *g;
 768   ec_curve *c;
 769   ec p = EC_INIT;
 770
 771   if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O:toec", KWLIST,
 772                                    &cty)) goto end;
 773   g = GROUP_G(GE_GOBJ(me));
 774   if (cty) {
 775     if (!PyType_Check(cty) || !PyType_IsSubtype(cty, ecpt_pytype))
 776       TYERR("want subtype of catacomb.ECPt");
 777     Py_INCREF((PyObject *)cty);
 778   } else if (STRCMP(G_NAME(g), ==, "ec")) {
 779     c = eccurve_copy(((gctx_ec *)g)->ei.c);
 780     cty = (PyTypeObject *)eccurve_pywrap(0, c);
 781   } else  {
 782     cty = ecpt_pytype;
 783     Py_INCREF((PyObject *)cty);
 784   }
 785   if (G_TOEC(GE_G(me), &p, GE_X(me))) {
 786     Py_DECREF((PyObject *)cty);
 787     TYERR("can't convert to ec point");
 788   }
 789   rc = ecpt_pywrapout(cty, &p);
 790   Py_DECREF((PyObject *)cty);
 791 end:
 792   return (rc);
 793 }
 794
 795 static PyObject *gemeth_tobuf(PyObject *me, PyObject *arg)
 796 {
 797   buf b;
 798   PyObject *rc;
 799   size_t n;
 800
 801   if (!PyArg_ParseTuple(arg, ":tobuf")) return (0);
 802   n = GE_G(me)->noctets + 4;
 803   rc = bytestring_pywrap(0, n);
 804   buf_init(&b, PyString_AS_STRING(rc), n);
 805   G_TOBUF(GE_G(me), &b, GE_X(me));
 806   assert(BOK(&b));
 807   _PyString_Resize(&rc, BLEN(&b));
 808   return (rc);
 809 }
 810
 811 static PyObject *gemeth_toraw(PyObject *me, PyObject *arg)
 812 {
 813   buf b;
 814   PyObject *rc;
 815   size_t n;
 816
 817   if (!PyArg_ParseTuple(arg, ":toraw")) return (0);
 818   n = GE_G(me)->noctets;
 819   rc = bytestring_pywrap(0, n);
 820   buf_init(&b, PyString_AS_STRING(rc), n);
 821   G_TORAW(GE_G(me), &b, GE_X(me));
 822   assert(BOK(&b));
 823   _PyString_Resize(&rc, BLEN(&b));
 824   return (rc);
 825 }
 826
 827 static PyObject *gmexp_exp(PyObject *me, void *pp, int n)
 828 {
 829   ge *z = G_CREATE(GROUP_G(me));
 830   G_MEXP(GROUP_G(me), z, pp, n);
 831   return (ge_pywrap(me, z));
 832 }
 833
 834 static void gmexp_drop(void *pp)
 835 {
 836   group_expfactor *f = pp;
 837   MP_DROP(f->exp);
 838 }
 839
 840 static PyObject *gmeth_mexp(PyObject *me, PyObject *arg)
 841 {
 842   return (mexp_common(me, arg, sizeof(group_expfactor),
 843                       gmexp_id, gmexp_fill, gmexp_exp, gmexp_drop));
 844 }
 845
 846 static PyObject *gmeth_checkgroup(PyObject *me, PyObject *arg, PyObject *kw)
 847 {
 848   static const char *const kwlist[] = { "rng", 0 };
 849   grand *r = &rand_global;
 850   const char *p;
 851
 852   if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:checkgroup", KWLIST,
 853                                    convgrand, &r))
 854     goto end;
 855   if ((p = G_CHECK(GROUP_G(me), r)) != 0)
 856     VALERR(p);
 857   RETURN_OBJ(me);
 858 end:
 859   return (0);
 860 }
 861
 862 static PyObject *group_pyrichcompare(PyObject *x, PyObject *y, int op)
 863 {
 864   int b = group_samep(GROUP_G(x), GROUP_G(y));
 865   switch (op) {
 866     case Py_EQ: break;
 867     case Py_NE: b = !b;
 868     default: TYERR("can't order groups");
 869   }
 870   return (getbool(b));
 871 end:
 872   return (0);
 873 }
 874
 875 static PyObject *gemeth_frombuf(PyObject *me, PyObject *arg)
 876 {
 877   buf b;
 878   char *p;
 879   Py_ssize_t n;
 880   group *g;
 881   ge *x = 0;
 882
 883   if (!PyArg_ParseTuple(arg, "s#:frombuf", &p, &n)) return (0);
 884   g = GROUP_G(me);
 885   buf_init(&b, p, n);
 886   x = G_CREATE(g);
 887   if (G_FROMBUF(g, &b, x)) VALERR("invalid data");
 888   return (Py_BuildValue("(NN)", ge_pywrap(me, x), bytestring_pywrapbuf(&b)));
 889 end:
 890   if (x) G_DESTROY(g, x);
 891   return (0);
 892 }
 893
 894 static PyObject *gemeth_fromraw(PyObject *me, PyObject *arg)
 895 {
 896   buf b;
 897   char *p;
 898   Py_ssize_t n;
 899   group *g;
 900   ge *x = 0;
 901
 902   if (!PyArg_ParseTuple(arg, "s#:fromraw", &p, &n)) return (0);
 903   g = GROUP_G(me);
 904   buf_init(&b, p, n);
 905   x = G_CREATE(g);
 906   if (G_FROMRAW(g, &b, x)) VALERR("invalid data");
 907   return (Py_BuildValue("(NN)", ge_pywrap(me, x), bytestring_pywrapbuf(&b)));
 908 end:
 909   if (x) G_DESTROY(g, x);
 910   return (0);
 911 }
 912
 913 static PyObject *gemeth_fromstring(PyObject *me, PyObject *arg)
 914 {
 915   mptext_stringctx sc;
 916   char *p;
 917   Py_ssize_t n;
 918   group *g;
 919   ge *x = 0;
 920
 921   if (!PyArg_ParseTuple(arg, "s#:fromstring", &p, &n)) return (0);
 922   sc.buf = p;
 923   sc.lim = sc.buf + n;
 924   g = GROUP_G(me);
 925   x = G_CREATE(g);
 926   if (G_READ(g, x, &mptext_stringops, &sc))
 927     VALERR("bad group element string");
 928   return (Py_BuildValue("(Ns#)", ge_pywrap(me, x),
 929                         sc.buf, (Py_ssize_t)(sc.lim - sc.buf)));
 930 end:
 931   if (x) G_DESTROY(g, x);
 932   return (0);
 933 }
 934
 935 static PyObject *gmeth_parse(PyObject *me, PyObject *arg)
 936 {
 937   char *p;
 938   qd_parse qd;
 939   group *g;
 940
 941   if (!PyArg_ParseTuple(arg, "s:parse", &p)) goto end;
 942   qd.p = p; qd.e = 0;
 943   if ((g = group_parse(&qd)) == 0) VALERR(qd.e);
 944   return (group_pywrap(g));
 945 end:
 946   return (0);
 947 }
 948
 949 static PyObject *geget_group(PyObject *me, void *hunoz)
 950   { RETURN_OBJ(GE_GOBJ(me)); }
 951
 952 static PyObject *gget_nbits(PyObject *me, void *hunoz)
 953   { return (PyInt_FromLong(GROUP_G(me)->nbits)); }
 954
 955 static PyObject *gget_noctets(PyObject *me, void *hunoz)
 956   { return (PyInt_FromLong(GROUP_G(me)->noctets)); }
 957
 958 static PyObject *gget_i(PyObject *me, void *hunoz)
 959 {
 960   group *g = GROUP_G(me); ge *x = G_CREATE(g);
 961   G_COPY(g, x, g->i); return (ge_pywrap(me, x));
 962 }
 963
 964 static PyObject *gget_g(PyObject *me, void *hunoz)
 965 {
 966   group *g = GROUP_G(me); ge *x = G_CREATE(g);
 967   G_COPY(g, x, g->g); return (ge_pywrap(me, x));
 968 }
 969
 970 static long ge_pyhash(PyObject *me)
 971 {
 972   buf b;
 973   size_t sz = GE_G(me)->noctets + 4;
 974   uint32 h = 0xf672c776 + GE_G(me)->ops->ty;
 975   octet *p = xmalloc(sz);
 976   buf_init(&b, p, sz);
 977   G_TOBUF(GE_G(me), &b, GE_X(me));
 978   assert(BOK(&b));
 979   h = unihash_hash(&unihash_global, h, BBASE(&b), BLEN(&b));
 980   xfree(p);
 981   return (h % LONG_MAX);
 982 }
 983
 984 static PyObject *gget_r(PyObject *me, void *hunoz)
 985   { return (mp_pywrap(MP_COPY(GROUP_G(me)->r))); }
 986
 987 static PyObject *gget_h(PyObject *me, void *hunoz)
 988   { return (mp_pywrap(MP_COPY(GROUP_G(me)->h))); }
 989
 990 static const PyGetSetDef ge_pygetset[] = {
 991 #define GETSETNAME(op, name) ge##op##_##name
 992   GET   (group,         "X.group -> group containing X")
 993 #undef GETSETNAME
 994   { 0 }
 995 };
 996
 997 static const PyMethodDef ge_pymethods[] = {
 998 #define METHNAME(name) gemeth_##name
 999   METH  (inv,           "X.inv() -> inverse element of X")
1000   METH  (sqr,           "X.sqr() -> X^2 = X * X")
1001   METH  (check,         "X.check() -> check X really belongs to its group")
1002   METH  (toint,         "X.toint() -> X converted to an integer")
1003   KWMETH(toec,          "X.toec([curve = ECPt]) -> "
1004                                        "X converted to elliptic curve point")
1005   METH  (tobuf,         "X.tobuf() -> X in buffer representation")
1006   METH  (toraw,         "X.toraw() -> X in raw representation")
1007   CMTH  (frombuf,       "frombuf(BUF) -> X, REST")
1008   CMTH  (fromraw,       "fromraw(BUF) -> X, REST")
1009   CMTH  (fromstring,    "fromstring(STR) -> X, REST")
1010 #undef METHNAME
1011   { 0 }
1012 };
1013
1014 static const PyNumberMethods ge_pynumber = {
1015   0,                                    /* @nb_add@ */
1016   0,                                    /* @nb_subtract@ */
1017   ge_pymul,                             /* @nb_multiply@ */
1018   ge_pydiv,                             /* @nb_divide@ */
1019   0,                                    /* @nb_remainder@ */
1020   0,                                    /* @nb_divmod@ */
1021   ge_pyexp,                             /* @nb_power@ */
1022   0,                                    /* @nb_negative@ */
1023   0,                                    /* @nb_positive@ */
1024   0,                                    /* @nb_absolute@ */
1025   ge_pynonzerop,                        /* @nb_nonzero@ */
1026   0,                                    /* @nb_invert@ */
1027   0,                                    /* @nb_lshift@ */
1028   0,                                    /* @nb_rshift@ */
1029   0,                                    /* @nb_and@ */
1030   0,                                    /* @nb_xor@ */
1031   0,                                    /* @nb_or@ */
1032   0,                                    /* @nb_coerce@ */
1033   ge_pyint,                             /* @nb_int@ */
1034   ge_pylong,                            /* @nb_long@ */
1035   0 /* meaningless */,                  /* @nb_float@ */
1036   0,                                    /* @nb_oct@ */
1037   0,                                    /* @nb_hex@ */
1038
1039   0,                                    /* @nb_inplace_add@ */
1040   0,                                    /* @nb_inplace_subtract@ */
1041   0,                                    /* @nb_inplace_multiply@ */
1042   0,                                    /* @nb_inplace_divide@ */
1043   0,                                    /* @nb_inplace_remainder@ */
1044   0,                                    /* @nb_inplace_power@ */
1045   0,                                    /* @nb_inplace_lshift@ */
1046   0,                                    /* @nb_inplace_rshift@ */
1047   0,                                    /* @nb_inplace_and@ */
1048   0,                                    /* @nb_inplace_xor@ */
1049   0,                                    /* @nb_inplace_or@ */
1050
1051   0,                                    /* @nb_floor_divide@ */
1052   ge_pydiv,                             /* @nb_true_divide@ */
1053   0,                                    /* @nb_inplace_floor_divide@ */
1054   0,                                    /* @nb_inplace_true_divide@ */
1055 };
1056
1057 static PyTypeObject ge_pytype_skel = {
1058   PyObject_HEAD_INIT(0) 0,              /* Header */
1059   "GE",                                 /* @tp_name@ */
1060   sizeof(ge_pyobj),                     /* @tp_basicsize@ */
1061   0,                                    /* @tp_itemsize@ */
1062
1063   ge_pydealloc,                         /* @tp_dealloc@ */
1064   0,                                    /* @tp_print@ */
1065   0,                                    /* @tp_getattr@ */
1066   0,                                    /* @tp_setattr@ */
1067   0,                                    /* @tp_compare@ */
1068   0,                                    /* @tp_repr@ */
1069   PYNUMBER(ge),                         /* @tp_as_number@ */
1070   0,                                    /* @tp_as_sequence@ */
1071   0,                                    /* @tp_as_mapping@ */
1072   ge_pyhash,                            /* @tp_hash@ */
1073   0,                                    /* @tp_call@ */
1074   ge_pystr,                             /* @tp_str@ */
1075   0,                                    /* @tp_getattro@ */
1076   0,                                    /* @tp_setattro@ */
1077   0,                                    /* @tp_as_buffer@ */
1078   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1079     Py_TPFLAGS_CHECKTYPES |
1080     Py_TPFLAGS_BASETYPE,
1081
1082   /* @tp_doc@ */
1083   "Group elements, abstract base class.",
1084
1085   0,                                    /* @tp_traverse@ */
1086   0,                                    /* @tp_clear@ */
1087   ge_pyrichcompare,                     /* @tp_richcompare@ */
1088   0,                                    /* @tp_weaklistoffset@ */
1089   0,                                    /* @tp_iter@ */
1090   0,                                    /* @tp_iternext@ */
1091   PYMETHODS(ge),                        /* @tp_methods@ */
1092   0,                                    /* @tp_members@ */
1093   PYGETSET(ge),                         /* @tp_getset@ */
1094   0,                                    /* @tp_base@ */
1095   0,                                    /* @tp_dict@ */
1096   0,                                    /* @tp_descr_get@ */
1097   0,                                    /* @tp_descr_set@ */
1098   0,                                    /* @tp_dictoffset@ */
1099   0,                                    /* @tp_init@ */
1100   PyType_GenericAlloc,                  /* @tp_alloc@ */
1101   abstract_pynew,                       /* @tp_new@ */
1102   0,                                    /* @tp_free@ */
1103   0                                     /* @tp_is_gc@ */
1104 };
1105
1106 static const PyGetSetDef group_pygetset[] = {
1107 #define GETSETNAME(op, name) g##op##_##name
1108   GET   (noctets,       "G.noctets -> size in octets of element")
1109   GET   (nbits,         "G.nbits -> size in bits of element")
1110   GET   (i,             "G.i -> group identity")
1111   GET   (g,             "G.g -> group generator")
1112   GET   (r,             "G.r -> group order")
1113   GET   (h,             "G.h -> group cofactor")
1114 #undef GETSETNAME
1115   { 0 }
1116 };
1117
1118 static const PyMethodDef group_pymethods[] = {
1119 #define METHNAME(name) gmeth_##name
1120   METH  (mexp,        "G.mexp([(X0, N0), (X1, N1), ...]) -> X0^N0 X1^N1 ...")
1121   KWMETH(checkgroup,    "G.checkgroup([rng = rand]): check group is good")
1122   SMTH  (parse,         "parse(STR) -> G, REST")
1123 #undef METHNAME
1124   { 0 }
1125 };
1126
1127 static PyTypeObject group_pytype_skel = {
1128   PyObject_HEAD_INIT(0) 0,              /* Header */
1129   "Group",                              /* @tp_name@ */
1130   sizeof(group_pyobj),                  /* @tp_basicsize@ */
1131   0,                                    /* @tp_itemsize@ */
1132
1133   group_pydealloc,                      /* @tp_dealloc@ */
1134   0,                                    /* @tp_print@ */
1135   0,                                    /* @tp_getattr@ */
1136   0,                                    /* @tp_setattr@ */
1137   0,                                    /* @tp_compare@ */
1138   0,                                    /* @tp_repr@ */
1139   0,                                    /* @tp_as_number@ */
1140   0,                                    /* @tp_as_sequence@ */
1141   0,                                    /* @tp_as_mapping@ */
1142   0,                                    /* @tp_hash@ */
1143   0,                                    /* @tp_call@ */
1144   0,                                    /* @tp_str@ */
1145   0,                                    /* @tp_getattro@ */
1146   0,                                    /* @tp_setattro@ */
1147   0,                                    /* @tp_as_buffer@ */
1148   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1149     Py_TPFLAGS_BASETYPE,
1150
1151   /* @tp_doc@ */
1152   "Abstract base class for groups.",
1153
1154   0,                                    /* @tp_traverse@ */
1155   0,                                    /* @tp_clear@ */
1156   group_pyrichcompare,                  /* @tp_richcompare@ */
1157   0,                                    /* @tp_weaklistoffset@ */
1158   0,                                    /* @tp_iter@ */
1159   0,                                    /* @tp_iternext@ */
1160   PYMETHODS(group),                     /* @tp_methods@ */
1161   0,                                    /* @tp_members@ */
1162   PYGETSET(group),                      /* @tp_getset@ */
1163   0,                                    /* @tp_base@ */
1164   0,                                    /* @tp_dict@ */
1165   0,                                    /* @tp_descr_get@ */
1166   0,                                    /* @tp_descr_set@ */
1167   0,                                    /* @tp_dictoffset@ */
1168   0,                                    /* @tp_init@ */
1169   PyType_GenericAlloc,                  /* @tp_alloc@ */
1170   abstract_pynew,                       /* @tp_new@ */
1171   0,                                    /* @tp_free@ */
1172   0                                     /* @tp_is_gc@ */
1173 };
1174
1175 static PyObject *pgget_info(PyObject *me, void *hunoz)
1176 {
1177   gprime_param dp;
1178   gctx_prime *gg = (gctx_prime *)GROUP_G(me);
1179   dp.p = MP_COPY(gg->mm.m);
1180   dp.q = MP_COPY(gg->g.r);
1181   dp.g = mpmont_reduce(&gg->mm, MP_NEW, gg->gen.x);
1182   return (fginfo_pywrap(&dp, dhinfo_pytype));
1183 }
1184
1185 static const PyGetSetDef primegroup_pygetset[] = {
1186 #define GETSETNAME(op, name) pg##op##_##name
1187   GET   (info,          "G.info -> information about the group")
1188 #undef GETSETNAME
1189   { 0 }
1190 };
1191
1192 static PyObject *primegroup_pynew(PyTypeObject *ty,
1193                                   PyObject *arg, PyObject *kw)
1194 {
1195   PyObject *i;
1196   static const char *const kwlist[] = { "info", 0 };
1197
1198   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!:new", KWLIST,
1199                                    dhinfo_pytype, &i))
1200     return (0);
1201   return (group_dopywrap(ty, group_prime(FGINFO_DP(i))));
1202 }
1203
1204 static PyTypeObject primegroup_pytype_skel = {
1205   PyObject_HEAD_INIT(0) 0,              /* Header */
1206   "PrimeGroup",                         /* @tp_name@ */
1207   sizeof(group_pyobj),                  /* @tp_basicsize@ */
1208   0,                                    /* @tp_itemsize@ */
1209
1210   group_pydealloc,                      /* @tp_dealloc@ */
1211   0,                                    /* @tp_print@ */
1212   0,                                    /* @tp_getattr@ */
1213   0,                                    /* @tp_setattr@ */
1214   0,                                    /* @tp_compare@ */
1215   0,                                    /* @tp_repr@ */
1216   0,                                    /* @tp_as_number@ */
1217   0,                                    /* @tp_as_sequence@ */
1218   0,                                    /* @tp_as_mapping@ */
1219   0,                                    /* @tp_hash@ */
1220   0,                                    /* @tp_call@ */
1221   0,                                    /* @tp_str@ */
1222   0,                                    /* @tp_getattro@ */
1223   0,                                    /* @tp_setattro@ */
1224   0,                                    /* @tp_as_buffer@ */
1225   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1226     Py_TPFLAGS_BASETYPE,
1227
1228   /* @tp_doc@ */
1229   "PrimeGroup(INFO): subgroups of prime fields.",
1230
1231   0,                                    /* @tp_traverse@ */
1232   0,                                    /* @tp_clear@ */
1233   0,                                    /* @tp_richcompare@ */
1234   0,                                    /* @tp_weaklistoffset@ */
1235   0,                                    /* @tp_iter@ */
1236   0,                                    /* @tp_iternext@ */
1237   0,                                    /* @tp_methods@ */
1238   0,                                    /* @tp_members@ */
1239   PYGETSET(primegroup),                 /* @tp_getset@ */
1240   0,                                    /* @tp_base@ */
1241   0,                                    /* @tp_dict@ */
1242   0,                                    /* @tp_descr_get@ */
1243   0,                                    /* @tp_descr_set@ */
1244   0,                                    /* @tp_dictoffset@ */
1245   0,                                    /* @tp_init@ */
1246   PyType_GenericAlloc,                  /* @tp_alloc@ */
1247   primegroup_pynew,                     /* @tp_new@ */
1248   0,                                    /* @tp_free@ */
1249   0                                     /* @tp_is_gc@ */
1250 };
1251
1252 static PyObject *bgget_info(PyObject *me, void *hunoz)
1253 {
1254   gbin_param dp;
1255   gctx_bin *gg = (gctx_bin *)GROUP_G(me);
1256   dp.p = MP_COPY(gg->r.p);
1257   dp.q = MP_COPY(gg->g.r);
1258   dp.g = MP_COPY(gg->gen.x);
1259   return (fginfo_pywrap(&dp, bindhinfo_pytype));
1260 }
1261
1262 static const PyGetSetDef bingroup_pygetset[] = {
1263 #define GETSETNAME(op, name) bg##op##_##name
1264   GET   (info,          "G.info -> information about the group")
1265 #undef GETSETNAME
1266   { 0 }
1267 };
1268
1269 static PyObject *bingroup_pynew(PyTypeObject *ty,
1270                                 PyObject *arg, PyObject *kw)
1271 {
1272   PyObject *i;
1273   static const char *const kwlist[] = { "info", 0 };
1274
1275   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!:new", KWLIST,
1276                                    bindhinfo_pytype, &i))
1277     return (0);
1278   return (group_dopywrap(ty, group_binary(FGINFO_DP(i))));
1279 }
1280
1281 static PyTypeObject bingroup_pytype_skel = {
1282   PyObject_HEAD_INIT(0) 0,              /* Header */
1283   "BinGroup",                           /* @tp_name@ */
1284   sizeof(group_pyobj),                  /* @tp_basicsize@ */
1285   0,                                    /* @tp_itemsize@ */
1286
1287   group_pydealloc,                      /* @tp_dealloc@ */
1288   0,                                    /* @tp_print@ */
1289   0,                                    /* @tp_getattr@ */
1290   0,                                    /* @tp_setattr@ */
1291   0,                                    /* @tp_compare@ */
1292   0,                                    /* @tp_repr@ */
1293   0,                                    /* @tp_as_number@ */
1294   0,                                    /* @tp_as_sequence@ */
1295   0,                                    /* @tp_as_mapping@ */
1296   0,                                    /* @tp_hash@ */
1297   0,                                    /* @tp_call@ */
1298   0,                                    /* @tp_str@ */
1299   0,                                    /* @tp_getattro@ */
1300   0,                                    /* @tp_setattro@ */
1301   0,                                    /* @tp_as_buffer@ */
1302   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1303     Py_TPFLAGS_BASETYPE,
1304
1305   /* @tp_doc@ */
1306   "BinGroup(INFO): subgroups of binary fields.",
1307
1308   0,                                    /* @tp_traverse@ */
1309   0,                                    /* @tp_clear@ */
1310   0,                                    /* @tp_richcompare@ */
1311   0,                                    /* @tp_weaklistoffset@ */
1312   0,                                    /* @tp_iter@ */
1313   0,                                    /* @tp_iternext@ */
1314   0,                                    /* @tp_methods@ */
1315   0,                                    /* @tp_members@ */
1316   PYGETSET(bingroup),                   /* @tp_getset@ */
1317   0,                                    /* @tp_base@ */
1318   0,                                    /* @tp_dict@ */
1319   0,                                    /* @tp_descr_get@ */
1320   0,                                    /* @tp_descr_set@ */
1321   0,                                    /* @tp_dictoffset@ */
1322   0,                                    /* @tp_init@ */
1323   PyType_GenericAlloc,                  /* @tp_alloc@ */
1324   bingroup_pynew,                       /* @tp_new@ */
1325   0,                                    /* @tp_free@ */
1326   0                                     /* @tp_is_gc@ */
1327 };
1328
1329 static PyObject *egget_info(PyObject *me, void *hunoz)
1330 {
1331   ec_info ei;
1332   gctx_ec *gg = (gctx_ec *)GROUP_G(me);
1333
1334   ecinfo_copy(&ei, &gg->ei);
1335   return (ecinfo_pywrap(&ei));
1336 }
1337
1338 static const PyGetSetDef ecgroup_pygetset[] = {
1339 #define GETSETNAME(op, name) eg##op##_##name
1340   GET   (info,          "G.info -> information about the group")
1341 #undef GETSETNAME
1342   { 0 }
1343 };
1344
1345 static PyObject *ecgroup_pynew(PyTypeObject *ty,
1346                                PyObject *arg, PyObject *kw)
1347 {
1348   PyObject *i;
1349   ec_info ei;
1350   static const char *const kwlist[] = { "info", 0 };
1351
1352   if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!:new", KWLIST,
1353                                    ecinfo_pytype, &i))
1354     return (0);
1355   ecinfo_copy(&ei, ECINFO_EI(i));
1356   return (group_dopywrap(ty, group_ec(&ei)));
1357 }
1358
1359 static PyTypeObject ecgroup_pytype_skel = {
1360   PyObject_HEAD_INIT(0) 0,              /* Header */
1361   "ECGroup",                            /* @tp_name@ */
1362   sizeof(group_pyobj),                  /* @tp_basicsize@ */
1363   0,                                    /* @tp_itemsize@ */
1364
1365   group_pydealloc,                      /* @tp_dealloc@ */
1366   0,                                    /* @tp_print@ */
1367   0,                                    /* @tp_getattr@ */
1368   0,                                    /* @tp_setattr@ */
1369   0,                                    /* @tp_compare@ */
1370   0,                                    /* @tp_repr@ */
1371   0,                                    /* @tp_as_number@ */
1372   0,                                    /* @tp_as_sequence@ */
1373   0,                                    /* @tp_as_mapping@ */
1374   0,                                    /* @tp_hash@ */
1375   0,                                    /* @tp_call@ */
1376   0,                                    /* @tp_str@ */
1377   0,                                    /* @tp_getattro@ */
1378   0,                                    /* @tp_setattro@ */
1379   0,                                    /* @tp_as_buffer@ */
1380   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1381     Py_TPFLAGS_BASETYPE,
1382
1383   /* @tp_doc@ */
1384   "ECGroup(INFO): elliptic curve groups.",
1385
1386   0,                                    /* @tp_traverse@ */
1387   0,                                    /* @tp_clear@ */
1388   0,                                    /* @tp_richcompare@ */
1389   0,                                    /* @tp_weaklistoffset@ */
1390   0,                                    /* @tp_iter@ */
1391   0,                                    /* @tp_iternext@ */
1392   0,                                    /* @tp_methods@ */
1393   0,                                    /* @tp_members@ */
1394   PYGETSET(ecgroup),                    /* @tp_getset@ */
1395   0,                                    /* @tp_base@ */
1396   0,                                    /* @tp_dict@ */
1397   0,                                    /* @tp_descr_get@ */
1398   0,                                    /* @tp_descr_set@ */
1399   0,                                    /* @tp_dictoffset@ */
1400   0,                                    /* @tp_init@ */
1401   PyType_GenericAlloc,                  /* @tp_alloc@ */
1402   ecgroup_pynew,                        /* @tp_new@ */
1403   0,                                    /* @tp_free@ */
1404   0                                     /* @tp_is_gc@ */
1405 };
1406
1407 /*----- Global stuff ------------------------------------------------------*/
1408
1409 void group_pyinit(void)
1410 {
1411   INITTYPE(fginfo, root);
1412   INITTYPE(dhinfo, fginfo);
1413   INITTYPE(bindhinfo, dhinfo);
1414   INITTYPE(ge, root);
1415   INITTYPE(group, type);
1416   INITTYPE(primegroup, group);
1417   INITTYPE(bingroup, group);
1418   INITTYPE(ecgroup, group);
1419 }
1420
1421 void group_pyinsert(PyObject *mod)
1422 {
1423   INSERT("FGInfo", fginfo_pytype);
1424   INSERT("DHInfo", dhinfo_pytype);
1425   INSERT("BinDHInfo", bindhinfo_pytype);
1426   INSERT("GE", ge_pytype);
1427   INSERT("Group", group_pytype);
1428   INSERT("PrimeGroup", primegroup_pytype);
1429   INSERT("BinGroup", bingroup_pytype);
1430   INSERT("ECGroup", ecgroup_pytype);
1431   INSERT("_pgroups", namedgroups(ptab, &npgroups));
1432   INSERT("_bingroups", namedgroups(bintab, &nbingroups));
1433 }
1434
1435 /*----- That's all, folks -------------------------------------------------*/