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

   1 /* -*-c-*-
   2  *
   3  * $Id$
   4  *
   5  * Symmetric cryptography
   6  *
   7  * (c) 2004 Straylight/Edgeware
   8  */
   9
  10 /*----- Licensing notice --------------------------------------------------*
  11  *
  12  * This file is part of the Python interface to Catacomb.
  13  *
  14  * Catacomb/Python 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/Python 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/Python; if not, write to the Free Software Foundation,
  26  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27  */
  28
  29 /*----- Header files ------------------------------------------------------*/
  30
  31 #include "catacomb-python.h"
  32 #include "algorithms.h"
  33
  34 /*----- Key sizes ---------------------------------------------------------*/
  35
  36 PyTypeObject *keysz_pytype;
  37 PyTypeObject *keyszany_pytype, *keyszrange_pytype, *keyszset_pytype;
  38 PyObject *sha_pyobj, *has160_pyobj;
  39
  40 PyObject *keysz_pywrap(const octet *k)
  41 {
  42   switch (k[0]) {
  43     case KSZ_ANY: {
  44       keysz_pyobj *o = PyObject_New(keysz_pyobj, keyszany_pytype);
  45       o->dfl = k[1];
  46       return ((PyObject *)o);
  47     } break;
  48     case KSZ_RANGE: {
  49       keyszrange_pyobj *o =
  50         PyObject_New(keyszrange_pyobj, keyszrange_pytype);
  51       o->dfl = k[1];
  52       o->min = k[2];
  53       o->max = k[3];
  54       o->mod = k[4];
  55       if (!o->mod) o->mod = 1;
  56       return ((PyObject *)o);
  57     } break;
  58     case KSZ_SET: {
  59       keyszset_pyobj *o =
  60         PyObject_New(keyszset_pyobj, keyszset_pytype);
  61       int i, n;
  62       o->dfl = k[1];
  63       for (i = 0; k[i + 1]; i++) ;
  64       n = i; o->set = PyTuple_New(n);
  65       for (i = 0; i < n; i++)
  66         PyTuple_SET_ITEM(o->set, i, PyInt_FromLong(k[i + 1]));
  67       return ((PyObject *)o);
  68     } break;
  69     default:
  70       abort();
  71   }
  72 }
  73
  74 static PyObject *keyszany_pynew(PyTypeObject *ty,
  75                                 PyObject *arg, PyObject *kw)
  76 {
  77   char *kwlist[] = { "default", 0 };
  78   int dfl;
  79   keysz_pyobj *o;
  80
  81   if (!PyArg_ParseTupleAndKeywords(arg, kw, "i:new", kwlist, &dfl))
  82     goto end;
  83   if (dfl < 0) VALERR("key size cannot be negative");
  84   o = (keysz_pyobj *)ty->tp_alloc(ty, 0);
  85   o->dfl = dfl;
  86   return ((PyObject *)o);
  87 end:
  88   return (0);
  89 }
  90
  91 static PyObject *keyszrange_pynew(PyTypeObject *ty,
  92                                   PyObject *arg, PyObject *kw)
  93 {
  94   char *kwlist[] = { "default", "min", "max", "mod", 0 };
  95   int dfl, min = 0, max = 0, mod = 1;
  96   keyszrange_pyobj *o;
  97
  98   if (!PyArg_ParseTupleAndKeywords(arg, kw, "i|iii:new", kwlist,
  99                                    &dfl, &min, &max, &mod))
 100     goto end;
 101   if (dfl < 0 || min < 0 || max < 0)
 102     VALERR("key size cannot be negative");
 103   if (min > dfl || (max && dfl > max))
 104     VALERR("bad key size bounds");
 105   if (mod <= 0 || dfl % mod || min % mod || max % mod)
 106     VALERR("bad key size modulus");
 107   o = (keyszrange_pyobj *)ty->tp_alloc(ty, 0);
 108   o->dfl = dfl;
 109   o->min = min;
 110   o->max = max;
 111   o->mod = mod;
 112   return ((PyObject *)o);
 113 end:
 114   return (0);
 115 }
 116
 117 static PyObject *keyszset_pynew(PyTypeObject *ty,
 118                                 PyObject *arg, PyObject *kw)
 119 {
 120   char *kwlist[] = { "default", "set", 0 };
 121   int dfl, i, n, xx;
 122   PyObject *set = 0;
 123   PyObject *x = 0, *l = 0;
 124   keyszset_pyobj *o = 0;
 125
 126   if (!PyArg_ParseTupleAndKeywords(arg, kw, "i|O:new", kwlist,
 127                                           &dfl, &set))
 128     goto end;
 129   if (!set) set = PyTuple_New(0);
 130   else Py_INCREF(set);
 131   if (!PySequence_Check(set)) TYERR("want a sequence");
 132   n = PySequence_Size(set);
 133   l = PyList_New(0);
 134   if (PyErr_Occurred()) goto end;
 135   if (dfl < 0) VALERR("key size cannot be negative");
 136   x = PyInt_FromLong(dfl);
 137   PyList_Append(l, x);
 138   Py_DECREF(x);
 139   x = 0;
 140   for (i = 0; i < n; i++) {
 141     if ((x = PySequence_GetItem(set, i)) == 0) goto end;
 142     xx = PyInt_AsLong(x);
 143     if (PyErr_Occurred()) goto end;
 144     if (xx == dfl) continue;
 145     if (xx < 0) VALERR("key size cannot be negative");
 146     PyList_Append(l, x);
 147     Py_DECREF(x);
 148     x = 0;
 149   }
 150   Py_DECREF(set);
 151   if ((set = PySequence_Tuple(l)) == 0) goto end;
 152   o = (keyszset_pyobj *)ty->tp_alloc(ty, 0);
 153   o->dfl = dfl;
 154   o->set = set;
 155   Py_INCREF(set);
 156 end:
 157   Py_XDECREF(set);
 158   Py_XDECREF(l);
 159   Py_XDECREF(x);
 160   return ((PyObject *)o);
 161 }
 162
 163 static PyObject *kaget_min(PyObject *me, void *hunoz)
 164   { return (PyInt_FromLong(0)); }
 165 #define kaget_max kaget_min
 166
 167 static PyObject *ksget_min(PyObject *me, void *hunoz)
 168 {
 169   PyObject *set = ((keyszset_pyobj *)me)->set;
 170   int i, n, y, x = -1;
 171   n = PyTuple_Size(set);
 172   for (i = 0; i < n; i++) {
 173     y = PyInt_AsLong(PyTuple_GetItem(set, i));
 174     if (x == -1 || y < x) x = y;
 175   }
 176   return (PyInt_FromLong(x));
 177 }
 178
 179 static PyObject *ksget_max(PyObject *me, void *hunoz)
 180 {
 181   PyObject *set = ((keyszset_pyobj *)me)->set;
 182   int i, n, y, x = -1;
 183   n = PyTuple_Size(set);
 184   for (i = 0; i < n; i++) {
 185     y = PyInt_AsLong(PyTuple_GetItem(set, i));
 186     if (y > x) x = y;
 187   }
 188   return (PyInt_FromLong(x));
 189 }
 190
 191 static PyMemberDef keysz_pymembers[] = {
 192 #define MEMBERSTRUCT keysz_pyobj
 193 #define default dfl /* ugh! */
 194   MEMBER(default, T_INT, READONLY, "KSZ.default -> default key size")
 195 #undef default
 196 #undef MEMBERSTRUCT
 197   { 0 }
 198 };
 199
 200 static PyGetSetDef keyszany_pygetset[] = {
 201 #define GETSETNAME(op, name) ka##op##_##name
 202   GET   (min,                   "KSZ.min -> smallest allowed key size")
 203   GET   (max,                   "KSZ.min -> largest allowed key size")
 204 #undef GETSETNAME
 205   { 0 }
 206 };
 207
 208 static PyMemberDef keyszrange_pymembers[] = {
 209 #define MEMBERSTRUCT keyszrange_pyobj
 210   MEMBER(min, T_INT, READONLY,  "KSZ.min -> smallest allowed key size")
 211   MEMBER(max, T_INT, READONLY,  "KSZ.min -> largest allowed key size")
 212   MEMBER(mod, T_INT, READONLY,
 213          "KSZ.mod -> key size must be a multiple of this")
 214 #undef MEMBERSTRUCT
 215   { 0 }
 216 };
 217
 218 static PyGetSetDef keyszset_pygetset[] = {
 219 #define GETSETNAME(op, name) ks##op##_##name
 220   GET   (min,                   "KSZ.min -> smallest allowed key size")
 221   GET   (max,                   "KSZ.min -> largest allowed key size")
 222 #undef GETSETNAME
 223   { 0 }
 224 };
 225
 226 static PyMemberDef keyszset_pymembers[] = {
 227 #define MEMBERSTRUCT keyszset_pyobj
 228   MEMBER(set, T_OBJECT, READONLY,       "KSZ.set -> allowed key sizes")
 229 #undef MEMBERSTRUCT
 230   { 0 }
 231 };
 232
 233 static PyTypeObject keysz_pytype_skel = {
 234   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 235   "catacomb.KeySZ",                     /* @tp_name@ */
 236   sizeof(keysz_pyobj),                  /* @tp_basicsize@ */
 237   0,                                    /* @tp_itemsize@ */
 238
 239   0,                                    /* @tp_dealloc@ */
 240   0,                                    /* @tp_print@ */
 241   0,                                    /* @tp_getattr@ */
 242   0,                                    /* @tp_setattr@ */
 243   0,                                    /* @tp_compare@ */
 244   0,                                    /* @tp_repr@ */
 245   0,                                    /* @tp_as_number@ */
 246   0,                                    /* @tp_as_sequence@ */
 247   0,                                    /* @tp_as_mapping@ */
 248   0,                                    /* @tp_hash@ */
 249   0,                                    /* @tp_call@ */
 250   0,                                    /* @tp_str@ */
 251   0,                                    /* @tp_getattro@ */
 252   0,                                    /* @tp_setattro@ */
 253   0,                                    /* @tp_as_buffer@ */
 254   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 255     Py_TPFLAGS_BASETYPE,
 256
 257   /* @tp_doc@ */
 258 "Key size constraints.",
 259
 260   0,                                    /* @tp_traverse@ */
 261   0,                                    /* @tp_clear@ */
 262   0,                                    /* @tp_richcompare@ */
 263   0,                                    /* @tp_weaklistoffset@ */
 264   0,                                    /* @tp_iter@ */
 265   0,                                    /* @tp_iternexr@ */
 266   0,                                    /* @tp_methods@ */
 267   keysz_pymembers,                      /* @tp_members@ */
 268   0,                                    /* @tp_getset@ */
 269   0,                                    /* @tp_base@ */
 270   0,                                    /* @tp_dict@ */
 271   0,                                    /* @tp_descr_get@ */
 272   0,                                    /* @tp_descr_set@ */
 273   0,                                    /* @tp_dictoffset@ */
 274   0,                                    /* @tp_init@ */
 275   PyType_GenericAlloc,                  /* @tp_alloc@ */
 276   abstract_pynew,                       /* @tp_new@ */
 277   0,                                    /* @tp_free@ */
 278   0                                     /* @tp_is_gc@ */
 279 };
 280
 281 static PyTypeObject keyszany_pytype_skel = {
 282   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 283   "catacomb.KeySZAny",                  /* @tp_name@ */
 284   sizeof(keysz_pyobj),                  /* @tp_basicsize@ */
 285   0,                                    /* @tp_itemsize@ */
 286
 287   0,                                    /* @tp_dealloc@ */
 288   0,                                    /* @tp_print@ */
 289   0,                                    /* @tp_getattr@ */
 290   0,                                    /* @tp_setattr@ */
 291   0,                                    /* @tp_compare@ */
 292   0,                                    /* @tp_repr@ */
 293   0,                                    /* @tp_as_number@ */
 294   0,                                    /* @tp_as_sequence@ */
 295   0,                                    /* @tp_as_mapping@ */
 296   0,                                    /* @tp_hash@ */
 297   0,                                    /* @tp_call@ */
 298   0,                                    /* @tp_str@ */
 299   0,                                    /* @tp_getattro@ */
 300   0,                                    /* @tp_setattro@ */
 301   0,                                    /* @tp_as_buffer@ */
 302   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 303     Py_TPFLAGS_BASETYPE,
 304
 305   /* @tp_doc@ */
 306 "Key size constraints.  This object imposes no constraints on size.",
 307
 308   0,                                    /* @tp_traverse@ */
 309   0,                                    /* @tp_clear@ */
 310   0,                                    /* @tp_richcompare@ */
 311   0,                                    /* @tp_weaklistoffset@ */
 312   0,                                    /* @tp_iter@ */
 313   0,                                    /* @tp_iternexr@ */
 314   0,                                    /* @tp_methods@ */
 315   0,                                    /* @tp_members@ */
 316   keyszany_pygetset,                    /* @tp_getset@ */
 317   0,                                    /* @tp_base@ */
 318   0,                                    /* @tp_dict@ */
 319   0,                                    /* @tp_descr_get@ */
 320   0,                                    /* @tp_descr_set@ */
 321   0,                                    /* @tp_dictoffset@ */
 322   0,                                    /* @tp_init@ */
 323   PyType_GenericAlloc,                  /* @tp_alloc@ */
 324   keyszany_pynew,                       /* @tp_new@ */
 325   0,                                    /* @tp_free@ */
 326   0                                     /* @tp_is_gc@ */
 327 };
 328
 329 static PyTypeObject keyszrange_pytype_skel = {
 330   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 331   "catacomb.KeySZRange",                /* @tp_name@ */
 332   sizeof(keyszrange_pyobj),             /* @tp_basicsize@ */
 333   0,                                    /* @tp_itemsize@ */
 334
 335   0,                                    /* @tp_dealloc@ */
 336   0,                                    /* @tp_print@ */
 337   0,                                    /* @tp_getattr@ */
 338   0,                                    /* @tp_setattr@ */
 339   0,                                    /* @tp_compare@ */
 340   0,                                    /* @tp_repr@ */
 341   0,                                    /* @tp_as_number@ */
 342   0,                                    /* @tp_as_sequence@ */
 343   0,                                    /* @tp_as_mapping@ */
 344   0,                                    /* @tp_hash@ */
 345   0,                                    /* @tp_call@ */
 346   0,                                    /* @tp_str@ */
 347   0,                                    /* @tp_getattro@ */
 348   0,                                    /* @tp_setattro@ */
 349   0,                                    /* @tp_as_buffer@ */
 350   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 351     Py_TPFLAGS_BASETYPE,
 352
 353   /* @tp_doc@ */
 354 "Key size constraints.  This object asserts minimum and maximum (if\n\
 355 sizes, and requires the key length to be a multiple of some value.",
 356
 357   0,                                    /* @tp_traverse@ */
 358   0,                                    /* @tp_clear@ */
 359   0,                                    /* @tp_richcompare@ */
 360   0,                                    /* @tp_weaklistoffset@ */
 361   0,                                    /* @tp_iter@ */
 362   0,                                    /* @tp_iternexr@ */
 363   0,                                    /* @tp_methods@ */
 364   keyszrange_pymembers,                 /* @tp_members@ */
 365   0,                                    /* @tp_getset@ */
 366   0,                                    /* @tp_base@ */
 367   0,                                    /* @tp_dict@ */
 368   0,                                    /* @tp_descr_get@ */
 369   0,                                    /* @tp_descr_set@ */
 370   0,                                    /* @tp_dictoffset@ */
 371   0,                                    /* @tp_init@ */
 372   PyType_GenericAlloc,                  /* @tp_alloc@ */
 373   keyszrange_pynew,                     /* @tp_new@ */
 374   0,                                    /* @tp_free@ */
 375   0                                     /* @tp_is_gc@ */
 376 };
 377
 378 static PyTypeObject keyszset_pytype_skel = {
 379   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 380   "catacomb.KeySZSet",                  /* @tp_name@ */
 381   sizeof(keyszset_pyobj),               /* @tp_basicsize@ */
 382   0,                                    /* @tp_itemsize@ */
 383
 384   0,                                    /* @tp_dealloc@ */
 385   0,                                    /* @tp_print@ */
 386   0,                                    /* @tp_getattr@ */
 387   0,                                    /* @tp_setattr@ */
 388   0,                                    /* @tp_compare@ */
 389   0,                                    /* @tp_repr@ */
 390   0,                                    /* @tp_as_number@ */
 391   0,                                    /* @tp_as_sequence@ */
 392   0,                                    /* @tp_as_mapping@ */
 393   0,                                    /* @tp_hash@ */
 394   0,                                    /* @tp_call@ */
 395   0,                                    /* @tp_str@ */
 396   0,                                    /* @tp_getattro@ */
 397   0,                                    /* @tp_setattro@ */
 398   0,                                    /* @tp_as_buffer@ */
 399   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 400     Py_TPFLAGS_BASETYPE,
 401
 402   /* @tp_doc@ */
 403 "Key size constraints.  This object requires the key to be one of a\n\
 404 few listed sizes.",
 405
 406   0,                                    /* @tp_traverse@ */
 407   0,                                    /* @tp_clear@ */
 408   0,                                    /* @tp_richcompare@ */
 409   0,                                    /* @tp_weaklistoffset@ */
 410   0,                                    /* @tp_iter@ */
 411   0,                                    /* @tp_iternexr@ */
 412   0,                                    /* @tp_methods@ */
 413   keyszset_pymembers,                   /* @tp_members@ */
 414   keyszset_pygetset,                    /* @tp_getset@ */
 415   0,                                    /* @tp_base@ */
 416   0,                                    /* @tp_dict@ */
 417   0,                                    /* @tp_descr_get@ */
 418   0,                                    /* @tp_descr_set@ */
 419   0,                                    /* @tp_dictoffset@ */
 420   0,                                    /* @tp_init@ */
 421   PyType_GenericAlloc,                  /* @tp_alloc@ */
 422   keyszset_pynew,                       /* @tp_new@ */
 423   0,                                    /* @tp_free@ */
 424   0                                     /* @tp_is_gc@ */
 425 };
 426
 427 /*----- Symmetric encryption ----------------------------------------------*/
 428
 429 PyTypeObject *gccipher_pytype, *gcipher_pytype;
 430
 431 CONVFUNC(gccipher, gccipher *, GCCIPHER_CC)
 432 CONVFUNC(gcipher, gcipher *, GCIPHER_C)
 433
 434 PyObject *gcipher_pywrap(PyObject *cobj, gcipher *c, unsigned f)
 435 {
 436   gcipher_pyobj *g;
 437   if (!cobj) cobj = gccipher_pywrap((/*unconst*/ gccipher *)GC_CLASS(c));
 438   else Py_INCREF(cobj);
 439   g = PyObject_NEW(gcipher_pyobj, (PyTypeObject *)cobj);
 440   g->c = c;
 441   g->f = f;
 442   return ((PyObject *)g);
 443 }
 444
 445 static PyObject *gcipher_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
 446 {
 447   char *kwlist[] = { "k", 0 };
 448   char *k;
 449   int sz;
 450
 451   if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", kwlist, &k, &sz))
 452     goto end;
 453   if (keysz(sz, GCCIPHER_CC(ty)->keysz) != sz) VALERR("bad key length");
 454   return (gcipher_pywrap((PyObject *)ty,
 455                          GC_INIT(GCCIPHER_CC(ty), k, sz),
 456                          f_freeme));
 457 end:
 458   return (0);
 459 }
 460
 461 PyObject *gccipher_pywrap(gccipher *cc)
 462 {
 463   gccipher_pyobj *g = newtype(gccipher_pytype, 0, cc->name);
 464   g->cc = cc;
 465   g->ty.type.tp_basicsize = sizeof(gcipher_pyobj);
 466   g->ty.type.tp_base = gcipher_pytype;
 467   Py_INCREF(gcipher_pytype);
 468   g->ty.type.tp_flags = (Py_TPFLAGS_DEFAULT |
 469                          Py_TPFLAGS_BASETYPE |
 470                          Py_TPFLAGS_HEAPTYPE);
 471   g->ty.type.tp_alloc = PyType_GenericAlloc;
 472   g->ty.type.tp_free = 0;
 473   g->ty.type.tp_new = gcipher_pynew;
 474   PyType_Ready(&g->ty.type);
 475   return ((PyObject *)g);
 476 }
 477
 478 static void gcipher_pydealloc(PyObject *me)
 479 {
 480   if (GCIPHER_F(me) & f_freeme)
 481     GC_DESTROY(GCIPHER_C(me));
 482   Py_DECREF(me->ob_type);
 483   FREEOBJ(me);
 484 }
 485
 486 static PyObject *gccget_name(PyObject *me, void *hunoz)
 487   { return (PyString_FromString(GCCIPHER_CC(me)->name)); }
 488
 489 static PyObject *gccget_keysz(PyObject *me, void *hunoz)
 490   { return (keysz_pywrap(GCCIPHER_CC(me)->keysz)); }
 491
 492 static PyObject *gccget_blksz(PyObject *me, void *hunoz)
 493   { return (PyInt_FromLong(GCCIPHER_CC(me)->blksz)); }
 494
 495 static PyObject *gcmeth_encrypt(PyObject *me, PyObject *arg)
 496 {
 497   char *p;
 498   int sz;
 499   PyObject *rc = 0;
 500
 501   if (!PyArg_ParseTuple(arg, "s#:encrypt", &p, &sz)) return (0);
 502   rc = bytestring_pywrap(0, sz);
 503   GC_ENCRYPT(GCIPHER_C(me), p, PyString_AS_STRING(rc), sz);
 504   return (rc);
 505 }
 506
 507 static PyObject *gcmeth_enczero(PyObject *me, PyObject *arg)
 508 {
 509   char *p;
 510   int sz;
 511   PyObject *rc = 0;
 512
 513   if (!PyArg_ParseTuple(arg, "i:enczero", &sz)) return (0);
 514   rc = bytestring_pywrap(0, sz);
 515   p = PyString_AS_STRING(rc);
 516   memset(p, 0, sz);
 517   GC_ENCRYPT(GCIPHER_C(me), p, p, sz);
 518   return (rc);
 519 }
 520
 521 static PyObject *gcmeth_decrypt(PyObject *me, PyObject *arg)
 522 {
 523   char *p;
 524   int sz;
 525   PyObject *rc = 0;
 526
 527   if (!PyArg_ParseTuple(arg, "s#:decrypt", &p, &sz)) return (0);
 528   rc = bytestring_pywrap(0, sz);
 529   GC_DECRYPT(GCIPHER_C(me), p, PyString_AS_STRING(rc), sz);
 530   return (rc);
 531 }
 532
 533 static PyObject *gcmeth_deczero(PyObject *me, PyObject *arg)
 534 {
 535   char *p;
 536   int sz;
 537   PyObject *rc = 0;
 538
 539   if (!PyArg_ParseTuple(arg, "i:deczero", &sz)) return (0);
 540   rc = bytestring_pywrap(0, sz);
 541   p = PyString_AS_STRING(rc);
 542   memset(p, 0, sz);
 543   GC_DECRYPT(GCIPHER_C(me), p, p, sz);
 544   return (rc);
 545 }
 546
 547 static PyObject *gcmeth_setiv(PyObject *me, PyObject *arg)
 548 {
 549   char *p;
 550   int sz;
 551
 552   if (!PyArg_ParseTuple(arg, "s#:setiv", &p, &sz)) goto end;
 553   if (!GC_CLASS(GCIPHER_C(me))->blksz) VALERR("not a block cipher mode");
 554   if (sz != GC_CLASS(GCIPHER_C(me))->blksz) VALERR("bad IV length");
 555   GC_SETIV(GCIPHER_C(me), p);
 556   RETURN_ME;
 557 end:
 558   return (0);
 559 }
 560
 561 static PyObject *gcmeth_bdry(PyObject *me, PyObject *arg)
 562 {
 563   if (!PyArg_ParseTuple(arg, ":bdry")) goto end;
 564   if (!GC_CLASS(GCIPHER_C(me))->blksz) VALERR("not a block cipher mode");
 565   GC_BDRY(GCIPHER_C(me));
 566   RETURN_ME;
 567 end:
 568   return (0);
 569 }
 570
 571 static PyGetSetDef gccipher_pygetset[] = {
 572 #define GETSETNAME(op, name) gcc##op##_##name
 573   GET   (keysz,                 "CC.keysz -> acceptable key sizes")
 574   GET   (blksz,                 "CC.blksz -> block size, or zero")
 575   GET   (name,                  "CC.name -> name of this kind of cipher")
 576 #undef GETSETNAME
 577   { 0 }
 578 };
 579
 580 static PyMethodDef gcipher_pymethods[] = {
 581 #define METHNAME(name) gcmeth_##name
 582   METH  (encrypt,               "C.encrypt(PT) -> CT")
 583   METH  (enczero,               "C.enczero(N) -> CT")
 584   METH  (decrypt,               "C.decrypt(CT) -> PT")
 585   METH  (deczero,               "C.deczero(N) -> PT")
 586   METH  (setiv,                 "C.setiv(IV)")
 587   METH  (bdry,                  "C.bdry()")
 588 #undef METHNAME
 589   { 0 }
 590 };
 591
 592 static PyTypeObject gccipher_pytype_skel = {
 593   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 594   "catacomb.GCCipher",                  /* @tp_name@ */
 595   sizeof(gccipher_pyobj),               /* @tp_basicsize@ */
 596   0,                                    /* @tp_itemsize@ */
 597
 598   0,                                    /* @tp_dealloc@ */
 599   0,                                    /* @tp_print@ */
 600   0,                                    /* @tp_getattr@ */
 601   0,                                    /* @tp_setattr@ */
 602   0,                                    /* @tp_compare@ */
 603   0,                                    /* @tp_repr@ */
 604   0,                                    /* @tp_as_number@ */
 605   0,                                    /* @tp_as_sequence@ */
 606   0,                                    /* @tp_as_mapping@ */
 607   0,                                    /* @tp_hash@ */
 608   0,                                    /* @tp_call@ */
 609   0,                                    /* @tp_str@ */
 610   0,                                    /* @tp_getattro@ */
 611   0,                                    /* @tp_setattro@ */
 612   0,                                    /* @tp_as_buffer@ */
 613   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 614     Py_TPFLAGS_BASETYPE,
 615
 616   /* @tp_doc@ */
 617 "Symmetric cipher metaclass.",
 618
 619   0,                                    /* @tp_traverse@ */
 620   0,                                    /* @tp_clear@ */
 621   0,                                    /* @tp_richcompare@ */
 622   0,                                    /* @tp_weaklistoffset@ */
 623   0,                                    /* @tp_iter@ */
 624   0,                                    /* @tp_iternexr@ */
 625   0,                                    /* @tp_methods@ */
 626   0,                                    /* @tp_members@ */
 627   gccipher_pygetset,                    /* @tp_getset@ */
 628   0,                                    /* @tp_base@ */
 629   0,                                    /* @tp_dict@ */
 630   0,                                    /* @tp_descr_get@ */
 631   0,                                    /* @tp_descr_set@ */
 632   0,                                    /* @tp_dictoffset@ */
 633   0,                                    /* @tp_init@ */
 634   PyType_GenericAlloc,                  /* @tp_alloc@ */
 635   abstract_pynew,                       /* @tp_new@ */
 636   0,                                    /* @tp_free@ */
 637   0                                     /* @tp_is_gc@ */
 638 };
 639
 640 static PyTypeObject gcipher_pytype_skel = {
 641   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 642   "catacomb.GCipher",                   /* @tp_name@ */
 643   sizeof(gcipher_pyobj),                /* @tp_basicsize@ */
 644   0,                                    /* @tp_itemsize@ */
 645
 646   gcipher_pydealloc,                    /* @tp_dealloc@ */
 647   0,                                    /* @tp_print@ */
 648   0,                                    /* @tp_getattr@ */
 649   0,                                    /* @tp_setattr@ */
 650   0,                                    /* @tp_compare@ */
 651   0,                                    /* @tp_repr@ */
 652   0,                                    /* @tp_as_number@ */
 653   0,                                    /* @tp_as_sequence@ */
 654   0,                                    /* @tp_as_mapping@ */
 655   0,                                    /* @tp_hash@ */
 656   0,                                    /* @tp_call@ */
 657   0,                                    /* @tp_str@ */
 658   0,                                    /* @tp_getattro@ */
 659   0,                                    /* @tp_setattro@ */
 660   0,                                    /* @tp_as_buffer@ */
 661   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 662     Py_TPFLAGS_BASETYPE,
 663
 664   /* @tp_doc@ */
 665 "Symmetric cipher, abstract base class.",
 666
 667   0,                                    /* @tp_traverse@ */
 668   0,                                    /* @tp_clear@ */
 669   0,                                    /* @tp_richcompare@ */
 670   0,                                    /* @tp_weaklistoffset@ */
 671   0,                                    /* @tp_iter@ */
 672   0,                                    /* @tp_iternexr@ */
 673   gcipher_pymethods,                    /* @tp_methods@ */
 674   0,                                    /* @tp_members@ */
 675   0,                                    /* @tp_getset@ */
 676   0,                                    /* @tp_base@ */
 677   0,                                    /* @tp_dict@ */
 678   0,                                    /* @tp_descr_get@ */
 679   0,                                    /* @tp_descr_set@ */
 680   0,                                    /* @tp_dictoffset@ */
 681   0,                                    /* @tp_init@ */
 682   PyType_GenericAlloc,                  /* @tp_alloc@ */
 683   abstract_pynew,                       /* @tp_new@ */
 684   0,                                    /* @tp_free@ */
 685   0                                     /* @tp_is_gc@ */
 686 };
 687
 688 /*----- Hash functions ----------------------------------------------------*/
 689
 690 PyTypeObject *gchash_pytype, *ghash_pytype;
 691
 692 CONVFUNC(gchash, gchash *, GCHASH_CH)
 693 CONVFUNC(ghash, ghash *, GHASH_H)
 694
 695 static PyObject *ghash_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
 696 {
 697   char *kwlist[] = { 0 };
 698   if (!PyArg_ParseTupleAndKeywords(arg, kw, ":new", kwlist))
 699     goto end;
 700   return (ghash_pywrap((PyObject *)ty, GH_INIT(GCHASH_CH(ty)), f_freeme));
 701 end:
 702   return (0);
 703 }
 704
 705 PyObject *gchash_pywrap(gchash *ch)
 706 {
 707   gchash_pyobj *g = newtype(gchash_pytype, 0, ch->name);
 708   g->ch = ch;
 709   g->ty.type.tp_basicsize = sizeof(ghash_pyobj);
 710   g->ty.type.tp_base = ghash_pytype;
 711   Py_INCREF(ghash_pytype);
 712   g->ty.type.tp_flags = (Py_TPFLAGS_DEFAULT |
 713                          Py_TPFLAGS_BASETYPE |
 714                          Py_TPFLAGS_HEAPTYPE);
 715   g->ty.type.tp_alloc = PyType_GenericAlloc;
 716   g->ty.type.tp_free = 0;
 717   g->ty.type.tp_new = ghash_pynew;
 718   PyType_Ready(&g->ty.type);
 719   return ((PyObject *)g);
 720 }
 721
 722 PyObject *ghash_pywrap(PyObject *cobj, ghash *h, unsigned f)
 723 {
 724   ghash_pyobj *g;
 725   if (!cobj) cobj = gchash_pywrap((/*unconst*/ gchash *)GH_CLASS(h));
 726   else Py_INCREF(cobj);
 727   g = PyObject_NEW(ghash_pyobj, (PyTypeObject *)cobj);
 728   g->h = h;
 729   g->f = f;
 730   return ((PyObject *)g);
 731 }
 732
 733 static void ghash_pydealloc(PyObject *me)
 734 {
 735   if (GHASH_F(me) & f_freeme)
 736     GH_DESTROY(GHASH_H(me));
 737   Py_DECREF(me->ob_type);
 738   FREEOBJ(me);
 739 }
 740
 741 static PyObject *gchget_name(PyObject *me, void *hunoz)
 742   { return (PyString_FromString(GCHASH_CH(me)->name)); }
 743
 744 static PyObject *gchget_hashsz(PyObject *me, void *hunoz)
 745   { return (PyInt_FromLong(GCHASH_CH(me)->hashsz)); }
 746
 747 static PyObject *gchget_bufsz(PyObject *me, void *hunoz)
 748   { return (PyInt_FromLong(GCHASH_CH(me)->bufsz)); }
 749
 750 static PyObject *ghmeth_hash(PyObject *me, PyObject *arg)
 751 {
 752   char *p;
 753   int sz;
 754   if (!PyArg_ParseTuple(arg, "s#:hash", &p, &sz)) return (0);
 755   GH_HASH(GHASH_H(me), p, sz);
 756   RETURN_ME;
 757 }
 758
 759 static PyObject *ghmeth_done(PyObject *me, PyObject *arg)
 760 {
 761   ghash *g;
 762   PyObject *rc;
 763   if (!PyArg_ParseTuple(arg, ":done")) return (0);
 764   g = GH_COPY(GHASH_H(me));
 765   rc = bytestring_pywrap(0, g->ops->c->hashsz);
 766   GH_DONE(g, PyString_AS_STRING(rc));
 767   GH_DESTROY(g);
 768   return (rc);
 769 }
 770
 771 static PyGetSetDef gchash_pygetset[] = {
 772 #define GETSETNAME(op, name) gch##op##_##name
 773   GET   (bufsz,                 "CH.bufsz -> hash buffer size, or zero")
 774   GET   (hashsz,                "CH.blksz -> hash output size")
 775   GET   (name,                  "CH.name -> name of this kind of hash")
 776 #undef GETSETNAME
 777   { 0 }
 778 };
 779
 780 static PyMethodDef ghash_pymethods[] = {
 781 #define METHNAME(name) ghmeth_##name
 782   METH  (hash,                  "H.hash(M)")
 783   METH  (done,                  "H.done() -> HASH")
 784 #undef METHNAME
 785   { 0 }
 786 };
 787
 788 static PyTypeObject gchash_pytype_skel = {
 789   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 790   "catacomb.GCHash",                    /* @tp_name@ */
 791   sizeof(gchash_pyobj),                 /* @tp_basicsize@ */
 792   0,                                    /* @tp_itemsize@ */
 793
 794   0,                                    /* @tp_dealloc@ */
 795   0,                                    /* @tp_print@ */
 796   0,                                    /* @tp_getattr@ */
 797   0,                                    /* @tp_setattr@ */
 798   0,                                    /* @tp_compare@ */
 799   0,                                    /* @tp_repr@ */
 800   0,                                    /* @tp_as_number@ */
 801   0,                                    /* @tp_as_sequence@ */
 802   0,                                    /* @tp_as_mapping@ */
 803   0,                                    /* @tp_hash@ */
 804   0,                                    /* @tp_call@ */
 805   0,                                    /* @tp_str@ */
 806   0,                                    /* @tp_getattro@ */
 807   0,                                    /* @tp_setattro@ */
 808   0,                                    /* @tp_as_buffer@ */
 809   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 810     Py_TPFLAGS_BASETYPE,
 811
 812   /* @tp_doc@ */
 813 "Hash function metaclass.",
 814
 815   0,                                    /* @tp_traverse@ */
 816   0,                                    /* @tp_clear@ */
 817   0,                                    /* @tp_richcompare@ */
 818   0,                                    /* @tp_weaklistoffset@ */
 819   0,                                    /* @tp_iter@ */
 820   0,                                    /* @tp_iternexr@ */
 821   0,                                    /* @tp_methods@ */
 822   0,                                    /* @tp_members@ */
 823   gchash_pygetset,                      /* @tp_getset@ */
 824   0,                                    /* @tp_base@ */
 825   0,                                    /* @tp_dict@ */
 826   0,                                    /* @tp_descr_get@ */
 827   0,                                    /* @tp_descr_set@ */
 828   0,                                    /* @tp_dictoffset@ */
 829   0,                                    /* @tp_init@ */
 830   PyType_GenericAlloc,                  /* @tp_alloc@ */
 831   abstract_pynew,                       /* @tp_new@ */
 832   0,                                    /* @tp_free@ */
 833   0                                     /* @tp_is_gc@ */
 834 };
 835
 836 static PyTypeObject ghash_pytype_skel = {
 837   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 838   "catacomb.GHash",                     /* @tp_name@ */
 839   sizeof(ghash_pyobj),                  /* @tp_basicsize@ */
 840   0,                                    /* @tp_itemsize@ */
 841
 842   ghash_pydealloc,                      /* @tp_dealloc@ */
 843   0,                                    /* @tp_print@ */
 844   0,                                    /* @tp_getattr@ */
 845   0,                                    /* @tp_setattr@ */
 846   0,                                    /* @tp_compare@ */
 847   0,                                    /* @tp_repr@ */
 848   0,                                    /* @tp_as_number@ */
 849   0,                                    /* @tp_as_sequence@ */
 850   0,                                    /* @tp_as_mapping@ */
 851   0,                                    /* @tp_hash@ */
 852   0,                                    /* @tp_call@ */
 853   0,                                    /* @tp_str@ */
 854   0,                                    /* @tp_getattro@ */
 855   0,                                    /* @tp_setattro@ */
 856   0,                                    /* @tp_as_buffer@ */
 857   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 858     Py_TPFLAGS_BASETYPE,
 859
 860   /* @tp_doc@ */
 861 "Hash function, abstract base class.",
 862
 863   0,                                    /* @tp_traverse@ */
 864   0,                                    /* @tp_clear@ */
 865   0,                                    /* @tp_richcompare@ */
 866   0,                                    /* @tp_weaklistoffset@ */
 867   0,                                    /* @tp_iter@ */
 868   0,                                    /* @tp_iternexr@ */
 869   ghash_pymethods,                      /* @tp_methods@ */
 870   0,                                    /* @tp_members@ */
 871   0,                                    /* @tp_getset@ */
 872   0,                                    /* @tp_base@ */
 873   0,                                    /* @tp_dict@ */
 874   0,                                    /* @tp_descr_get@ */
 875   0,                                    /* @tp_descr_set@ */
 876   0,                                    /* @tp_dictoffset@ */
 877   0,                                    /* @tp_init@ */
 878   PyType_GenericAlloc,                  /* @tp_alloc@ */
 879   abstract_pynew,                       /* @tp_new@ */
 880   0,                                    /* @tp_free@ */
 881   0                                     /* @tp_is_gc@ */
 882 };
 883
 884 /*----- Message authentication --------------------------------------------*/
 885
 886 PyTypeObject *gcmac_pytype, *gmac_pytype, *gmhash_pytype;
 887
 888 CONVFUNC(gcmac, gcmac *, GCMAC_CM)
 889 CONVFUNC(gmac, gmac *, GMAC_M)
 890 CONVFUNC(gmhash, ghash *, GHASH_H)
 891
 892 static PyObject *gmac_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
 893 {
 894   char *kwlist[] = { "k", 0 };
 895   char *k;
 896   int sz;
 897
 898   if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", kwlist, &k, &sz))
 899     goto end;
 900   if (keysz(sz, GCMAC_CM(ty)->keysz) != sz) VALERR("bad key length");
 901   return (gmac_pywrap((PyObject *)ty,
 902                       GM_KEY(GCMAC_CM(ty), k, sz),
 903                       f_freeme));
 904 end:
 905   return (0);
 906 }
 907
 908 static PyObject *gmhash_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
 909 {
 910   char *kwlist[] = { 0 };
 911   ghash_pyobj *g;
 912
 913   if (!PyArg_ParseTupleAndKeywords(arg, kw, ":new", kwlist)) return (0);
 914   g = PyObject_NEW(ghash_pyobj, ty);
 915   g->h = GM_INIT(GMAC_M(ty));
 916   g->f = f_freeme;
 917   Py_INCREF(ty);
 918   return ((PyObject *)g);
 919 }
 920
 921 PyObject *gcmac_pywrap(gcmac *cm)
 922 {
 923   gcmac_pyobj *g = newtype(gcmac_pytype, 0, cm->name);
 924   g->cm = cm;
 925   g->ty.type.tp_basicsize = sizeof(gmac_pyobj);
 926   g->ty.type.tp_base = gmac_pytype;
 927   Py_INCREF(gmac_pytype);
 928   g->ty.type.tp_flags = (Py_TPFLAGS_DEFAULT |
 929                     Py_TPFLAGS_BASETYPE |
 930                     Py_TPFLAGS_HEAPTYPE);
 931   g->ty.type.tp_alloc = PyType_GenericAlloc;
 932   g->ty.type.tp_free = 0;
 933   g->ty.type.tp_new = gmac_pynew;
 934   PyType_Ready(&g->ty.type);
 935   return ((PyObject *)g);
 936 }
 937
 938 PyObject *gmac_pywrap(PyObject *cobj, gmac *m, unsigned f)
 939 {
 940   gmac_pyobj *g;
 941   if (!cobj) cobj = gcmac_pywrap((/*unconst*/ gcmac *)GM_CLASS(m));
 942   else Py_INCREF(cobj);
 943   g = newtype((PyTypeObject *)cobj, 0, 0);
 944   g->ty.name = PyString_FromFormat("%s(keyed)", m->ops->c->name);
 945   g->ty.type.tp_name = PyString_AS_STRING(g->ty.name);
 946   g->ty.type.tp_base = gmhash_pytype;
 947   Py_INCREF(gmac_pytype);
 948   g->ty.type.tp_flags = (Py_TPFLAGS_DEFAULT |
 949                          Py_TPFLAGS_BASETYPE |
 950                          Py_TPFLAGS_HEAPTYPE);
 951   g->ty.type.tp_alloc = PyType_GenericAlloc;
 952   g->ty.type.tp_free = 0;
 953   g->ty.type.tp_new = gmhash_pynew;
 954   PyType_Ready(&g->ty.type);
 955   g->m = m;
 956   g->f = f;
 957   return ((PyObject *)g);
 958 }
 959
 960 static void gmac_pydealloc(PyObject *me)
 961 {
 962   if (GMAC_F(me) & f_freeme)
 963     GM_DESTROY(GMAC_M(me));
 964   Py_DECREF(me->ob_type);
 965   PyType_Type.tp_dealloc(me);
 966 }
 967
 968 static PyObject *gcmget_name(PyObject *me, void *hunoz)
 969   { return (PyString_FromString(GCMAC_CM(me)->name)); }
 970
 971 static PyObject *gcmget_keysz(PyObject *me, void *hunoz)
 972   { return (keysz_pywrap(GCMAC_CM(me)->keysz)); }
 973
 974 static PyObject *gcmget_tagsz(PyObject *me, void *hunoz)
 975   { return (PyInt_FromLong(GCMAC_CM(me)->hashsz)); }
 976
 977 static PyGetSetDef gcmac_pygetset[] = {
 978 #define GETSETNAME(op, name) gcm##op##_##name
 979   GET   (keysz,                 "CM.keysz -> acceptable key sizes")
 980   GET   (tagsz,                 "CM.tagsz -> MAC output size")
 981   GET   (name,                  "CM.name -> name of this kind of MAC")
 982 #undef GETSETNAME
 983   { 0 }
 984 };
 985
 986 static PyTypeObject gcmac_pytype_skel = {
 987   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 988   "catacomb.GCMAC",                     /* @tp_name@ */
 989   sizeof(gchash_pyobj),                 /* @tp_basicsize@ */
 990   0,                                    /* @tp_itemsize@ */
 991
 992   0,                                    /* @tp_dealloc@ */
 993   0,                                    /* @tp_print@ */
 994   0,                                    /* @tp_getattr@ */
 995   0,                                    /* @tp_setattr@ */
 996   0,                                    /* @tp_compare@ */
 997   0,                                    /* @tp_repr@ */
 998   0,                                    /* @tp_as_number@ */
 999   0,                                    /* @tp_as_sequence@ */
1000   0,                                    /* @tp_as_mapping@ */
1001   0,                                    /* @tp_hash@ */
1002   0,                                    /* @tp_call@ */
1003   0,                                    /* @tp_str@ */
1004   0,                                    /* @tp_getattro@ */
1005   0,                                    /* @tp_setattro@ */
1006   0,                                    /* @tp_as_buffer@ */
1007   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1008     Py_TPFLAGS_BASETYPE,
1009
1010   /* @tp_doc@ */
1011 "Message authentication code metametaclass.",
1012
1013   0,                                    /* @tp_traverse@ */
1014   0,                                    /* @tp_clear@ */
1015   0,                                    /* @tp_richcompare@ */
1016   0,                                    /* @tp_weaklistoffset@ */
1017   0,                                    /* @tp_iter@ */
1018   0,                                    /* @tp_iternexr@ */
1019   0,                                    /* @tp_methods@ */
1020   0,                                    /* @tp_members@ */
1021   gcmac_pygetset,                       /* @tp_getset@ */
1022   0,                                    /* @tp_base@ */
1023   0,                                    /* @tp_dict@ */
1024   0,                                    /* @tp_descr_get@ */
1025   0,                                    /* @tp_descr_set@ */
1026   0,                                    /* @tp_dictoffset@ */
1027   0,                                    /* @tp_init@ */
1028   PyType_GenericAlloc,                  /* @tp_alloc@ */
1029   abstract_pynew,                       /* @tp_new@ */
1030   0,                                    /* @tp_free@ */
1031   0                                     /* @tp_is_gc@ */
1032 };
1033
1034 static PyTypeObject gmac_pytype_skel = {
1035   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
1036   "catacomb.GMAC",                      /* @tp_name@ */
1037   sizeof(gmac_pyobj),                   /* @tp_basicsize@ */
1038   0,                                    /* @tp_itemsize@ */
1039
1040   gmac_pydealloc,                       /* @tp_dealloc@ */
1041   0,                                    /* @tp_print@ */
1042   0,                                    /* @tp_getattr@ */
1043   0,                                    /* @tp_setattr@ */
1044   0,                                    /* @tp_compare@ */
1045   0,                                    /* @tp_repr@ */
1046   0,                                    /* @tp_as_number@ */
1047   0,                                    /* @tp_as_sequence@ */
1048   0,                                    /* @tp_as_mapping@ */
1049   0,                                    /* @tp_hash@ */
1050   0,                                    /* @tp_call@ */
1051   0,                                    /* @tp_str@ */
1052   0,                                    /* @tp_getattro@ */
1053   0,                                    /* @tp_setattro@ */
1054   0,                                    /* @tp_as_buffer@ */
1055   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1056     Py_TPFLAGS_BASETYPE,
1057
1058   /* @tp_doc@ */
1059 "Message authentication code metaclass, abstract base class.",
1060
1061   0,                                    /* @tp_traverse@ */
1062   0,                                    /* @tp_clear@ */
1063   0,                                    /* @tp_richcompare@ */
1064   0,                                    /* @tp_weaklistoffset@ */
1065   0,                                    /* @tp_iter@ */
1066   0,                                    /* @tp_iternexr@ */
1067   0,                                    /* @tp_methods@ */
1068   0,                                    /* @tp_members@ */
1069   0,                                    /* @tp_getset@ */
1070   0,                                    /* @tp_base@ */
1071   0,                                    /* @tp_dict@ */
1072   0,                                    /* @tp_descr_get@ */
1073   0,                                    /* @tp_descr_set@ */
1074   0,                                    /* @tp_dictoffset@ */
1075   0,                                    /* @tp_init@ */
1076   PyType_GenericAlloc,                  /* @tp_alloc@ */
1077   abstract_pynew,                       /* @tp_new@ */
1078   0,                                    /* @tp_free@ */
1079   0                                     /* @tp_is_gc@ */
1080 };
1081
1082 static PyTypeObject gmhash_pytype_skel = {
1083   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
1084   "catacomb.GMACHash",                  /* @tp_name@ */
1085   sizeof(ghash_pyobj),                  /* @tp_basicsize@ */
1086   0,                                    /* @tp_itemsize@ */
1087
1088   ghash_pydealloc,                      /* @tp_dealloc@ */
1089   0,                                    /* @tp_print@ */
1090   0,                                    /* @tp_getattr@ */
1091   0,                                    /* @tp_setattr@ */
1092   0,                                    /* @tp_compare@ */
1093   0,                                    /* @tp_repr@ */
1094   0,                                    /* @tp_as_number@ */
1095   0,                                    /* @tp_as_sequence@ */
1096   0,                                    /* @tp_as_mapping@ */
1097   0,                                    /* @tp_hash@ */
1098   0,                                    /* @tp_call@ */
1099   0,                                    /* @tp_str@ */
1100   0,                                    /* @tp_getattro@ */
1101   0,                                    /* @tp_setattro@ */
1102   0,                                    /* @tp_as_buffer@ */
1103   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1104     Py_TPFLAGS_BASETYPE,
1105
1106   /* @tp_doc@ */
1107 "Message authentication code, abstract base class.",
1108
1109   0,                                    /* @tp_traverse@ */
1110   0,                                    /* @tp_clear@ */
1111   0,                                    /* @tp_richcompare@ */
1112   0,                                    /* @tp_weaklistoffset@ */
1113   0,                                    /* @tp_iter@ */
1114   0,                                    /* @tp_iternexr@ */
1115   0,                                    /* @tp_methods@ */
1116   0,                                    /* @tp_members@ */
1117   0,                                    /* @tp_getset@ */
1118   0,                                    /* @tp_base@ */
1119   0,                                    /* @tp_dict@ */
1120   0,                                    /* @tp_descr_get@ */
1121   0,                                    /* @tp_descr_set@ */
1122   0,                                    /* @tp_dictoffset@ */
1123   0,                                    /* @tp_init@ */
1124   PyType_GenericAlloc,                  /* @tp_alloc@ */
1125   abstract_pynew,                       /* @tp_new@ */
1126   0,                                    /* @tp_free@ */
1127   0                                     /* @tp_is_gc@ */
1128 };
1129
1130 /*----- Main code ---------------------------------------------------------*/
1131
1132 void algorithms_pyinit(void)
1133 {
1134   INITTYPE(keysz, root);
1135   INITTYPE(keyszany, keysz);
1136   INITTYPE(keyszrange, keysz);
1137   INITTYPE(keyszset, keysz);
1138   INITTYPE(gccipher, type);
1139   INITTYPE(gcipher, root);
1140   INITTYPE(gchash, type);
1141   INITTYPE(ghash, root);
1142   INITTYPE(gcmac, type);
1143   INITTYPE(gmac, type);
1144   INITTYPE(gmhash, ghash);
1145 }
1146
1147 #define GEN(func, base)                                                 \
1148   static PyObject *func(void)                                           \
1149   {                                                                     \
1150     PyObject *d = PyDict_New();                                         \
1151     PyObject *o;                                                        \
1152     int i;                                                              \
1153                                                                         \
1154     for (i = 0; g##base##tab[i]; i++) {                                 \
1155       o = gc##base##_pywrap((/*unconst*/ gc##base *)g##base##tab[i]);   \
1156       PyDict_SetItemString(d,                                           \
1157                            (/*unconst*/ char *)g##base##tab[i]->name,   \
1158                            o);                                          \
1159       Py_DECREF(o);                                                     \
1160     }                                                                   \
1161     return (d);                                                         \
1162   }
1163 GEN(gcciphers, cipher)
1164 GEN(gchashes, hash)
1165 GEN(gcmacs, mac)
1166
1167 void algorithms_pyinsert(PyObject *mod)
1168 {
1169   PyObject *d;
1170   INSERT("KeySZ", keysz_pytype);
1171   INSERT("KeySZAny", keyszany_pytype);
1172   INSERT("KeySZRange", keyszrange_pytype);
1173   INSERT("KeySZSet", keyszset_pytype);
1174   INSERT("GCCipher", gccipher_pytype);
1175   INSERT("GCipher", gcipher_pytype);
1176   INSERT("gcciphers", gcciphers());
1177   INSERT("GCHash", gchash_pytype);
1178   INSERT("GHash", ghash_pytype);
1179   INSERT("gchashes", d = gchashes());
1180   sha_pyobj = PyDict_GetItemString(d, "sha"); Py_INCREF(sha_pyobj);
1181   has160_pyobj = PyDict_GetItemString(d, "has160"); Py_INCREF(has160_pyobj);
1182   INSERT("GCMAC", gcmac_pytype);
1183   INSERT("GMAC", gmac_pytype);
1184   INSERT("GMACHash", gmhash_pytype);
1185   INSERT("gcmacs", gcmacs());
1186 }
1187
1188 /*----- That's all, folks -------------------------------------------------*/