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);
 464   g->cc = cc;
 465   g->ty.tp_name = (/*unconst*/ char *)cc->name;
 466   g->ty.tp_basicsize = sizeof(gcipher_pyobj);
 467   g->ty.tp_base = gcipher_pytype;
 468   Py_INCREF(gcipher_pytype);
 469   g->ty.tp_flags = (Py_TPFLAGS_DEFAULT |
 470                     Py_TPFLAGS_BASETYPE |
 471                     Py_TPFLAGS_HEAPTYPE);
 472   g->ty.tp_alloc = PyType_GenericAlloc;
 473   g->ty.tp_free = 0;
 474   g->ty.tp_new = gcipher_pynew;
 475   PyType_Ready(&g->ty);
 476   return ((PyObject *)g);
 477 }
 478
 479 static void gcipher_pydealloc(PyObject *me)
 480 {
 481   if (GCIPHER_F(me) & f_freeme)
 482     GC_DESTROY(GCIPHER_C(me));
 483   Py_DECREF(me->ob_type);
 484   FREEOBJ(me);
 485 }
 486
 487 static PyObject *gccget_name(PyObject *me, void *hunoz)
 488   { return (PyString_FromString(GCCIPHER_CC(me)->name)); }
 489
 490 static PyObject *gccget_keysz(PyObject *me, void *hunoz)
 491   { return (keysz_pywrap(GCCIPHER_CC(me)->keysz)); }
 492
 493 static PyObject *gccget_blksz(PyObject *me, void *hunoz)
 494   { return (PyInt_FromLong(GCCIPHER_CC(me)->blksz)); }
 495
 496 static PyObject *gcmeth_encrypt(PyObject *me, PyObject *arg)
 497 {
 498   char *p;
 499   int sz;
 500   PyObject *rc = 0;
 501
 502   if (!PyArg_ParseTuple(arg, "s#:encrypt", &p, &sz)) return (0);
 503   rc = bytestring_pywrap(0, sz);
 504   GC_ENCRYPT(GCIPHER_C(me), p, PyString_AS_STRING(rc), sz);
 505   return (rc);
 506 }
 507
 508 static PyObject *gcmeth_enczero(PyObject *me, PyObject *arg)
 509 {
 510   char *p;
 511   int sz;
 512   PyObject *rc = 0;
 513
 514   if (!PyArg_ParseTuple(arg, "i:enczero", &sz)) return (0);
 515   rc = bytestring_pywrap(0, sz);
 516   p = PyString_AS_STRING(rc);
 517   memset(p, 0, sz);
 518   GC_ENCRYPT(GCIPHER_C(me), p, p, sz);
 519   return (rc);
 520 }
 521
 522 static PyObject *gcmeth_decrypt(PyObject *me, PyObject *arg)
 523 {
 524   char *p;
 525   int sz;
 526   PyObject *rc = 0;
 527
 528   if (!PyArg_ParseTuple(arg, "s#:decrypt", &p, &sz)) return (0);
 529   rc = bytestring_pywrap(0, sz);
 530   GC_DECRYPT(GCIPHER_C(me), p, PyString_AS_STRING(rc), sz);
 531   return (rc);
 532 }
 533
 534 static PyObject *gcmeth_deczero(PyObject *me, PyObject *arg)
 535 {
 536   char *p;
 537   int sz;
 538   PyObject *rc = 0;
 539
 540   if (!PyArg_ParseTuple(arg, "i:deczero", &sz)) return (0);
 541   rc = bytestring_pywrap(0, sz);
 542   p = PyString_AS_STRING(rc);
 543   memset(p, 0, sz);
 544   GC_DECRYPT(GCIPHER_C(me), p, p, sz);
 545   return (rc);
 546 }
 547
 548 static PyObject *gcmeth_setiv(PyObject *me, PyObject *arg)
 549 {
 550   char *p;
 551   int sz;
 552
 553   if (!PyArg_ParseTuple(arg, "s#:setiv", &p, &sz)) goto end;
 554   if (!GC_CLASS(GCIPHER_C(me))->blksz) VALERR("not a block cipher mode");
 555   if (sz != GC_CLASS(GCIPHER_C(me))->blksz) VALERR("bad IV length");
 556   GC_SETIV(GCIPHER_C(me), p);
 557   RETURN_ME;
 558 end:
 559   return (0);
 560 }
 561
 562 static PyObject *gcmeth_bdry(PyObject *me, PyObject *arg)
 563 {
 564   if (!PyArg_ParseTuple(arg, ":bdry")) goto end;
 565   if (!GC_CLASS(GCIPHER_C(me))->blksz) VALERR("not a block cipher mode");
 566   GC_BDRY(GCIPHER_C(me));
 567   RETURN_ME;
 568 end:
 569   return (0);
 570 }
 571
 572 static PyGetSetDef gccipher_pygetset[] = {
 573 #define GETSETNAME(op, name) gcc##op##_##name
 574   GET   (keysz,                 "CC.keysz -> acceptable key sizes")
 575   GET   (blksz,                 "CC.blksz -> block size, or zero")
 576   GET   (name,                  "CC.name -> name of this kind of cipher")
 577 #undef GETSETNAME
 578   { 0 }
 579 };
 580
 581 static PyMethodDef gcipher_pymethods[] = {
 582 #define METHNAME(name) gcmeth_##name
 583   METH  (encrypt,               "C.encrypt(PT) -> CT")
 584   METH  (enczero,               "C.enczero(N) -> CT")
 585   METH  (decrypt,               "C.decrypt(CT) -> PT")
 586   METH  (deczero,               "C.deczero(N) -> PT")
 587   METH  (setiv,                 "C.setiv(IV)")
 588   METH  (bdry,                  "C.bdry()")
 589 #undef METHNAME
 590   { 0 }
 591 };
 592
 593 static PyTypeObject gccipher_pytype_skel = {
 594   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 595   "catacomb.GCCipher",                  /* @tp_name@ */
 596   sizeof(gccipher_pyobj),               /* @tp_basicsize@ */
 597   0,                                    /* @tp_itemsize@ */
 598
 599   0,                                    /* @tp_dealloc@ */
 600   0,                                    /* @tp_print@ */
 601   0,                                    /* @tp_getattr@ */
 602   0,                                    /* @tp_setattr@ */
 603   0,                                    /* @tp_compare@ */
 604   0,                                    /* @tp_repr@ */
 605   0,                                    /* @tp_as_number@ */
 606   0,                                    /* @tp_as_sequence@ */
 607   0,                                    /* @tp_as_mapping@ */
 608   0,                                    /* @tp_hash@ */
 609   0,                                    /* @tp_call@ */
 610   0,                                    /* @tp_str@ */
 611   0,                                    /* @tp_getattro@ */
 612   0,                                    /* @tp_setattro@ */
 613   0,                                    /* @tp_as_buffer@ */
 614   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 615     Py_TPFLAGS_BASETYPE,
 616
 617   /* @tp_doc@ */
 618 "Symmetric cipher metaclass.",
 619
 620   0,                                    /* @tp_traverse@ */
 621   0,                                    /* @tp_clear@ */
 622   0,                                    /* @tp_richcompare@ */
 623   0,                                    /* @tp_weaklistoffset@ */
 624   0,                                    /* @tp_iter@ */
 625   0,                                    /* @tp_iternexr@ */
 626   0,                                    /* @tp_methods@ */
 627   0,                                    /* @tp_members@ */
 628   gccipher_pygetset,                    /* @tp_getset@ */
 629   0,                                    /* @tp_base@ */
 630   0,                                    /* @tp_dict@ */
 631   0,                                    /* @tp_descr_get@ */
 632   0,                                    /* @tp_descr_set@ */
 633   0,                                    /* @tp_dictoffset@ */
 634   0,                                    /* @tp_init@ */
 635   PyType_GenericAlloc,                  /* @tp_alloc@ */
 636   abstract_pynew,                       /* @tp_new@ */
 637   0,                                    /* @tp_free@ */
 638   0                                     /* @tp_is_gc@ */
 639 };
 640
 641 static PyTypeObject gcipher_pytype_skel = {
 642   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 643   "catacomb.GCipher",                   /* @tp_name@ */
 644   sizeof(gcipher_pyobj),                /* @tp_basicsize@ */
 645   0,                                    /* @tp_itemsize@ */
 646
 647   gcipher_pydealloc,                    /* @tp_dealloc@ */
 648   0,                                    /* @tp_print@ */
 649   0,                                    /* @tp_getattr@ */
 650   0,                                    /* @tp_setattr@ */
 651   0,                                    /* @tp_compare@ */
 652   0,                                    /* @tp_repr@ */
 653   0,                                    /* @tp_as_number@ */
 654   0,                                    /* @tp_as_sequence@ */
 655   0,                                    /* @tp_as_mapping@ */
 656   0,                                    /* @tp_hash@ */
 657   0,                                    /* @tp_call@ */
 658   0,                                    /* @tp_str@ */
 659   0,                                    /* @tp_getattro@ */
 660   0,                                    /* @tp_setattro@ */
 661   0,                                    /* @tp_as_buffer@ */
 662   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 663     Py_TPFLAGS_BASETYPE,
 664
 665   /* @tp_doc@ */
 666 "Symmetric cipher, abstract base class.",
 667
 668   0,                                    /* @tp_traverse@ */
 669   0,                                    /* @tp_clear@ */
 670   0,                                    /* @tp_richcompare@ */
 671   0,                                    /* @tp_weaklistoffset@ */
 672   0,                                    /* @tp_iter@ */
 673   0,                                    /* @tp_iternexr@ */
 674   gcipher_pymethods,                    /* @tp_methods@ */
 675   0,                                    /* @tp_members@ */
 676   0,                                    /* @tp_getset@ */
 677   0,                                    /* @tp_base@ */
 678   0,                                    /* @tp_dict@ */
 679   0,                                    /* @tp_descr_get@ */
 680   0,                                    /* @tp_descr_set@ */
 681   0,                                    /* @tp_dictoffset@ */
 682   0,                                    /* @tp_init@ */
 683   PyType_GenericAlloc,                  /* @tp_alloc@ */
 684   abstract_pynew,                       /* @tp_new@ */
 685   0,                                    /* @tp_free@ */
 686   0                                     /* @tp_is_gc@ */
 687 };
 688
 689 /*----- Hash functions ----------------------------------------------------*/
 690
 691 PyTypeObject *gchash_pytype, *ghash_pytype;
 692
 693 CONVFUNC(gchash, gchash *, GCHASH_CH)
 694 CONVFUNC(ghash, ghash *, GHASH_H)
 695
 696 static PyObject *ghash_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
 697 {
 698   char *kwlist[] = { 0 };
 699   if (!PyArg_ParseTupleAndKeywords(arg, kw, ":new", kwlist))
 700     goto end;
 701   return (ghash_pywrap((PyObject *)ty, GH_INIT(GCHASH_CH(ty)), f_freeme));
 702 end:
 703   return (0);
 704 }
 705
 706 PyObject *gchash_pywrap(gchash *ch)
 707 {
 708   gchash_pyobj *g = newtype(gchash_pytype, 0);
 709   g->ch = ch;
 710   g->ty.tp_name = (/*unconst*/ char *)ch->name;
 711   g->ty.tp_basicsize = sizeof(ghash_pyobj);
 712   g->ty.tp_base = ghash_pytype;
 713   Py_INCREF(ghash_pytype);
 714   g->ty.tp_flags = (Py_TPFLAGS_DEFAULT |
 715                     Py_TPFLAGS_BASETYPE |
 716                     Py_TPFLAGS_HEAPTYPE);
 717   g->ty.tp_alloc = PyType_GenericAlloc;
 718   g->ty.tp_free = 0;
 719   g->ty.tp_new = ghash_pynew;
 720   PyType_Ready(&g->ty);
 721   return ((PyObject *)g);
 722 }
 723
 724 PyObject *ghash_pywrap(PyObject *cobj, ghash *h, unsigned f)
 725 {
 726   ghash_pyobj *g;
 727   if (!cobj) cobj = gchash_pywrap((/*unconst*/ gchash *)GH_CLASS(h));
 728   else Py_INCREF(cobj);
 729   g = PyObject_NEW(ghash_pyobj, (PyTypeObject *)cobj);
 730   g->h = h;
 731   g->f = f;
 732   return ((PyObject *)g);
 733 }
 734
 735 static void ghash_pydealloc(PyObject *me)
 736 {
 737   if (GHASH_F(me) & f_freeme)
 738     GH_DESTROY(GHASH_H(me));
 739   Py_DECREF(me->ob_type);
 740   FREEOBJ(me);
 741 }
 742
 743 static PyObject *gchget_name(PyObject *me, void *hunoz)
 744   { return (PyString_FromString(GCHASH_CH(me)->name)); }
 745
 746 static PyObject *gchget_hashsz(PyObject *me, void *hunoz)
 747   { return (PyInt_FromLong(GCHASH_CH(me)->hashsz)); }
 748
 749 static PyObject *gchget_bufsz(PyObject *me, void *hunoz)
 750   { return (PyInt_FromLong(GCHASH_CH(me)->bufsz)); }
 751
 752 static PyObject *ghmeth_hash(PyObject *me, PyObject *arg)
 753 {
 754   char *p;
 755   int sz;
 756   if (!PyArg_ParseTuple(arg, "s#:hash", &p, &sz)) return (0);
 757   GH_HASH(GHASH_H(me), p, sz);
 758   RETURN_ME;
 759 }
 760
 761 static PyObject *ghmeth_done(PyObject *me, PyObject *arg)
 762 {
 763   ghash *g;
 764   PyObject *rc;
 765   if (!PyArg_ParseTuple(arg, ":done")) return (0);
 766   g = GH_COPY(GHASH_H(me));
 767   rc = bytestring_pywrap(0, g->ops->c->hashsz);
 768   GH_DONE(g, PyString_AS_STRING(rc));
 769   GH_DESTROY(g);
 770   return (rc);
 771 }
 772
 773 static PyGetSetDef gchash_pygetset[] = {
 774 #define GETSETNAME(op, name) gch##op##_##name
 775   GET   (bufsz,                 "CH.bufsz -> hash buffer size, or zero")
 776   GET   (hashsz,                "CH.blksz -> hash output size")
 777   GET   (name,                  "CH.name -> name of this kind of hash")
 778 #undef GETSETNAME
 779   { 0 }
 780 };
 781
 782 static PyMethodDef ghash_pymethods[] = {
 783 #define METHNAME(name) ghmeth_##name
 784   METH  (hash,                  "H.hash(M)")
 785   METH  (done,                  "H.done() -> HASH")
 786 #undef METHNAME
 787   { 0 }
 788 };
 789
 790 static PyTypeObject gchash_pytype_skel = {
 791   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 792   "catacomb.GCHash",                    /* @tp_name@ */
 793   sizeof(gchash_pyobj),                 /* @tp_basicsize@ */
 794   0,                                    /* @tp_itemsize@ */
 795
 796   0,                                    /* @tp_dealloc@ */
 797   0,                                    /* @tp_print@ */
 798   0,                                    /* @tp_getattr@ */
 799   0,                                    /* @tp_setattr@ */
 800   0,                                    /* @tp_compare@ */
 801   0,                                    /* @tp_repr@ */
 802   0,                                    /* @tp_as_number@ */
 803   0,                                    /* @tp_as_sequence@ */
 804   0,                                    /* @tp_as_mapping@ */
 805   0,                                    /* @tp_hash@ */
 806   0,                                    /* @tp_call@ */
 807   0,                                    /* @tp_str@ */
 808   0,                                    /* @tp_getattro@ */
 809   0,                                    /* @tp_setattro@ */
 810   0,                                    /* @tp_as_buffer@ */
 811   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 812     Py_TPFLAGS_BASETYPE,
 813
 814   /* @tp_doc@ */
 815 "Hash function metaclass.",
 816
 817   0,                                    /* @tp_traverse@ */
 818   0,                                    /* @tp_clear@ */
 819   0,                                    /* @tp_richcompare@ */
 820   0,                                    /* @tp_weaklistoffset@ */
 821   0,                                    /* @tp_iter@ */
 822   0,                                    /* @tp_iternexr@ */
 823   0,                                    /* @tp_methods@ */
 824   0,                                    /* @tp_members@ */
 825   gchash_pygetset,                      /* @tp_getset@ */
 826   0,                                    /* @tp_base@ */
 827   0,                                    /* @tp_dict@ */
 828   0,                                    /* @tp_descr_get@ */
 829   0,                                    /* @tp_descr_set@ */
 830   0,                                    /* @tp_dictoffset@ */
 831   0,                                    /* @tp_init@ */
 832   PyType_GenericAlloc,                  /* @tp_alloc@ */
 833   abstract_pynew,                       /* @tp_new@ */
 834   0,                                    /* @tp_free@ */
 835   0                                     /* @tp_is_gc@ */
 836 };
 837
 838 static PyTypeObject ghash_pytype_skel = {
 839   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 840   "catacomb.GHash",                     /* @tp_name@ */
 841   sizeof(ghash_pyobj),                  /* @tp_basicsize@ */
 842   0,                                    /* @tp_itemsize@ */
 843
 844   ghash_pydealloc,                      /* @tp_dealloc@ */
 845   0,                                    /* @tp_print@ */
 846   0,                                    /* @tp_getattr@ */
 847   0,                                    /* @tp_setattr@ */
 848   0,                                    /* @tp_compare@ */
 849   0,                                    /* @tp_repr@ */
 850   0,                                    /* @tp_as_number@ */
 851   0,                                    /* @tp_as_sequence@ */
 852   0,                                    /* @tp_as_mapping@ */
 853   0,                                    /* @tp_hash@ */
 854   0,                                    /* @tp_call@ */
 855   0,                                    /* @tp_str@ */
 856   0,                                    /* @tp_getattro@ */
 857   0,                                    /* @tp_setattro@ */
 858   0,                                    /* @tp_as_buffer@ */
 859   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 860     Py_TPFLAGS_BASETYPE,
 861
 862   /* @tp_doc@ */
 863 "Hash function, abstract base class.",
 864
 865   0,                                    /* @tp_traverse@ */
 866   0,                                    /* @tp_clear@ */
 867   0,                                    /* @tp_richcompare@ */
 868   0,                                    /* @tp_weaklistoffset@ */
 869   0,                                    /* @tp_iter@ */
 870   0,                                    /* @tp_iternexr@ */
 871   ghash_pymethods,                      /* @tp_methods@ */
 872   0,                                    /* @tp_members@ */
 873   0,                                    /* @tp_getset@ */
 874   0,                                    /* @tp_base@ */
 875   0,                                    /* @tp_dict@ */
 876   0,                                    /* @tp_descr_get@ */
 877   0,                                    /* @tp_descr_set@ */
 878   0,                                    /* @tp_dictoffset@ */
 879   0,                                    /* @tp_init@ */
 880   PyType_GenericAlloc,                  /* @tp_alloc@ */
 881   abstract_pynew,                       /* @tp_new@ */
 882   0,                                    /* @tp_free@ */
 883   0                                     /* @tp_is_gc@ */
 884 };
 885
 886 /*----- Message authentication --------------------------------------------*/
 887
 888 PyTypeObject *gcmac_pytype, *gmac_pytype, *gmhash_pytype;
 889
 890 CONVFUNC(gcmac, gcmac *, GCMAC_CM)
 891 CONVFUNC(gmac, gmac *, GMAC_M)
 892 CONVFUNC(gmhash, ghash *, GHASH_H)
 893
 894 static PyObject *gmac_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
 895 {
 896   char *kwlist[] = { "k", 0 };
 897   char *k;
 898   int sz;
 899
 900   if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", kwlist, &k, &sz))
 901     goto end;
 902   if (keysz(sz, GCMAC_CM(ty)->keysz) != sz) VALERR("bad key length");
 903   return (gmac_pywrap((PyObject *)ty,
 904                       GM_KEY(GCMAC_CM(ty), k, sz),
 905                       f_freeme));
 906 end:
 907   return (0);
 908 }
 909
 910 static PyObject *gmhash_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
 911 {
 912   char *kwlist[] = { 0 };
 913   ghash_pyobj *g;
 914
 915   if (!PyArg_ParseTupleAndKeywords(arg, kw, ":new", kwlist)) return (0);
 916   g = PyObject_NEW(ghash_pyobj, ty);
 917   g->h = GM_INIT(GMAC_M(ty));
 918   g->f = f_freeme;
 919   Py_INCREF(ty);
 920   return ((PyObject *)g);
 921 }
 922
 923 PyObject *gcmac_pywrap(gcmac *cm)
 924 {
 925   gcmac_pyobj *g = newtype(gcmac_pytype, 0);
 926   g->cm = cm;
 927   g->ty.tp_name = (/*unconst*/ char *)cm->name;
 928   g->ty.tp_basicsize = sizeof(gmac_pyobj);
 929   g->ty.tp_base = gmac_pytype;
 930   Py_INCREF(gmac_pytype);
 931   g->ty.tp_flags = (Py_TPFLAGS_DEFAULT |
 932                     Py_TPFLAGS_BASETYPE |
 933                     Py_TPFLAGS_HEAPTYPE);
 934   g->ty.tp_alloc = PyType_GenericAlloc;
 935   g->ty.tp_free = 0;
 936   g->ty.tp_new = gmac_pynew;
 937   PyType_Ready(&g->ty);
 938   return ((PyObject *)g);
 939 }
 940
 941 PyObject *gmac_pywrap(PyObject *cobj, gmac *m, unsigned f)
 942 {
 943   gmac_pyobj *g;
 944   if (!cobj) cobj = gcmac_pywrap((/*unconst*/ gcmac *)GM_CLASS(m));
 945   else Py_INCREF(cobj);
 946   g = newtype((PyTypeObject *)cobj, 0);
 947   g->nameobj = PyString_FromFormat("%s(keyed)", m->ops->c->name);
 948   g->ty.tp_name = PyString_AS_STRING(g->nameobj);
 949   g->ty.tp_base = gmhash_pytype;
 950   Py_INCREF(gmac_pytype);
 951   g->ty.tp_flags = (Py_TPFLAGS_DEFAULT |
 952                     Py_TPFLAGS_BASETYPE |
 953                     Py_TPFLAGS_HEAPTYPE);
 954   g->ty.tp_alloc = PyType_GenericAlloc;
 955   g->ty.tp_free = 0;
 956   g->ty.tp_new = gmhash_pynew;
 957   PyType_Ready(&g->ty);
 958   g->m = m;
 959   g->f = f;
 960   return ((PyObject *)g);
 961 }
 962
 963 static void gmac_pydealloc(PyObject *me)
 964 {
 965   if (GMAC_F(me) & f_freeme)
 966     GM_DESTROY(GMAC_M(me));
 967   Py_DECREF(me->ob_type);
 968   Py_DECREF(GMAC_NAMEOBJ(me));
 969   PyType_Type.tp_dealloc(me);
 970 }
 971
 972 static PyObject *gcmget_name(PyObject *me, void *hunoz)
 973   { return (PyString_FromString(GCMAC_CM(me)->name)); }
 974
 975 static PyObject *gcmget_keysz(PyObject *me, void *hunoz)
 976   { return (keysz_pywrap(GCMAC_CM(me)->keysz)); }
 977
 978 static PyObject *gcmget_tagsz(PyObject *me, void *hunoz)
 979   { return (PyInt_FromLong(GCMAC_CM(me)->hashsz)); }
 980
 981 static PyGetSetDef gcmac_pygetset[] = {
 982 #define GETSETNAME(op, name) gcm##op##_##name
 983   GET   (keysz,                 "CM.keysz -> acceptable key sizes")
 984   GET   (tagsz,                 "CM.tagsz -> MAC output size")
 985   GET   (name,                  "CM.name -> name of this kind of MAC")
 986 #undef GETSETNAME
 987   { 0 }
 988 };
 989
 990 static PyTypeObject gcmac_pytype_skel = {
 991   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
 992   "catacomb.GCMAC",                     /* @tp_name@ */
 993   sizeof(gchash_pyobj),                 /* @tp_basicsize@ */
 994   0,                                    /* @tp_itemsize@ */
 995
 996   0,                                    /* @tp_dealloc@ */
 997   0,                                    /* @tp_print@ */
 998   0,                                    /* @tp_getattr@ */
 999   0,                                    /* @tp_setattr@ */
1000   0,                                    /* @tp_compare@ */
1001   0,                                    /* @tp_repr@ */
1002   0,                                    /* @tp_as_number@ */
1003   0,                                    /* @tp_as_sequence@ */
1004   0,                                    /* @tp_as_mapping@ */
1005   0,                                    /* @tp_hash@ */
1006   0,                                    /* @tp_call@ */
1007   0,                                    /* @tp_str@ */
1008   0,                                    /* @tp_getattro@ */
1009   0,                                    /* @tp_setattro@ */
1010   0,                                    /* @tp_as_buffer@ */
1011   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1012     Py_TPFLAGS_BASETYPE,
1013
1014   /* @tp_doc@ */
1015 "Message authentication code metametaclass.",
1016
1017   0,                                    /* @tp_traverse@ */
1018   0,                                    /* @tp_clear@ */
1019   0,                                    /* @tp_richcompare@ */
1020   0,                                    /* @tp_weaklistoffset@ */
1021   0,                                    /* @tp_iter@ */
1022   0,                                    /* @tp_iternexr@ */
1023   0,                                    /* @tp_methods@ */
1024   0,                                    /* @tp_members@ */
1025   gcmac_pygetset,                       /* @tp_getset@ */
1026   0,                                    /* @tp_base@ */
1027   0,                                    /* @tp_dict@ */
1028   0,                                    /* @tp_descr_get@ */
1029   0,                                    /* @tp_descr_set@ */
1030   0,                                    /* @tp_dictoffset@ */
1031   0,                                    /* @tp_init@ */
1032   PyType_GenericAlloc,                  /* @tp_alloc@ */
1033   abstract_pynew,                       /* @tp_new@ */
1034   0,                                    /* @tp_free@ */
1035   0                                     /* @tp_is_gc@ */
1036 };
1037
1038 static PyTypeObject gmac_pytype_skel = {
1039   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
1040   "catacomb.GMAC",                      /* @tp_name@ */
1041   sizeof(gmac_pyobj),                   /* @tp_basicsize@ */
1042   0,                                    /* @tp_itemsize@ */
1043
1044   gmac_pydealloc,                       /* @tp_dealloc@ */
1045   0,                                    /* @tp_print@ */
1046   0,                                    /* @tp_getattr@ */
1047   0,                                    /* @tp_setattr@ */
1048   0,                                    /* @tp_compare@ */
1049   0,                                    /* @tp_repr@ */
1050   0,                                    /* @tp_as_number@ */
1051   0,                                    /* @tp_as_sequence@ */
1052   0,                                    /* @tp_as_mapping@ */
1053   0,                                    /* @tp_hash@ */
1054   0,                                    /* @tp_call@ */
1055   0,                                    /* @tp_str@ */
1056   0,                                    /* @tp_getattro@ */
1057   0,                                    /* @tp_setattro@ */
1058   0,                                    /* @tp_as_buffer@ */
1059   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1060     Py_TPFLAGS_BASETYPE,
1061
1062   /* @tp_doc@ */
1063 "Message authentication code metaclass, abstract base class.",
1064
1065   0,                                    /* @tp_traverse@ */
1066   0,                                    /* @tp_clear@ */
1067   0,                                    /* @tp_richcompare@ */
1068   0,                                    /* @tp_weaklistoffset@ */
1069   0,                                    /* @tp_iter@ */
1070   0,                                    /* @tp_iternexr@ */
1071   0,                                    /* @tp_methods@ */
1072   0,                                    /* @tp_members@ */
1073   0,                                    /* @tp_getset@ */
1074   0,                                    /* @tp_base@ */
1075   0,                                    /* @tp_dict@ */
1076   0,                                    /* @tp_descr_get@ */
1077   0,                                    /* @tp_descr_set@ */
1078   0,                                    /* @tp_dictoffset@ */
1079   0,                                    /* @tp_init@ */
1080   PyType_GenericAlloc,                  /* @tp_alloc@ */
1081   abstract_pynew,                       /* @tp_new@ */
1082   0,                                    /* @tp_free@ */
1083   0                                     /* @tp_is_gc@ */
1084 };
1085
1086 static PyTypeObject gmhash_pytype_skel = {
1087   PyObject_HEAD_INIT(&PyType_Type) 0,   /* Header */
1088   "catacomb.GMACHash",                  /* @tp_name@ */
1089   sizeof(ghash_pyobj),                  /* @tp_basicsize@ */
1090   0,                                    /* @tp_itemsize@ */
1091
1092   ghash_pydealloc,                      /* @tp_dealloc@ */
1093   0,                                    /* @tp_print@ */
1094   0,                                    /* @tp_getattr@ */
1095   0,                                    /* @tp_setattr@ */
1096   0,                                    /* @tp_compare@ */
1097   0,                                    /* @tp_repr@ */
1098   0,                                    /* @tp_as_number@ */
1099   0,                                    /* @tp_as_sequence@ */
1100   0,                                    /* @tp_as_mapping@ */
1101   0,                                    /* @tp_hash@ */
1102   0,                                    /* @tp_call@ */
1103   0,                                    /* @tp_str@ */
1104   0,                                    /* @tp_getattro@ */
1105   0,                                    /* @tp_setattro@ */
1106   0,                                    /* @tp_as_buffer@ */
1107   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
1108     Py_TPFLAGS_BASETYPE,
1109
1110   /* @tp_doc@ */
1111 "Message authentication code, abstract base class.",
1112
1113   0,                                    /* @tp_traverse@ */
1114   0,                                    /* @tp_clear@ */
1115   0,                                    /* @tp_richcompare@ */
1116   0,                                    /* @tp_weaklistoffset@ */
1117   0,                                    /* @tp_iter@ */
1118   0,                                    /* @tp_iternexr@ */
1119   0,                                    /* @tp_methods@ */
1120   0,                                    /* @tp_members@ */
1121   0,                                    /* @tp_getset@ */
1122   0,                                    /* @tp_base@ */
1123   0,                                    /* @tp_dict@ */
1124   0,                                    /* @tp_descr_get@ */
1125   0,                                    /* @tp_descr_set@ */
1126   0,                                    /* @tp_dictoffset@ */
1127   0,                                    /* @tp_init@ */
1128   PyType_GenericAlloc,                  /* @tp_alloc@ */
1129   abstract_pynew,                       /* @tp_new@ */
1130   0,                                    /* @tp_free@ */
1131   0                                     /* @tp_is_gc@ */
1132 };
1133
1134 /*----- Main code ---------------------------------------------------------*/
1135
1136 void algorithms_pyinit(void)
1137 {
1138   INITTYPE(keysz, root);
1139   INITTYPE(keyszany, keysz);
1140   INITTYPE(keyszrange, keysz);
1141   INITTYPE(keyszset, keysz);
1142   INITTYPE(gccipher, type);
1143   INITTYPE(gcipher, root);
1144   INITTYPE(gchash, type);
1145   INITTYPE(ghash, root);
1146   INITTYPE(gcmac, type);
1147   INITTYPE(gmac, type);
1148   INITTYPE(gmhash, ghash);
1149 }
1150
1151 #define GEN(func, base)                                                 \
1152   static PyObject *func(void)                                           \
1153   {                                                                     \
1154     PyObject *d = PyDict_New();                                         \
1155     PyObject *o;                                                        \
1156     int i;                                                              \
1157                                                                         \
1158     for (i = 0; g##base##tab[i]; i++) {                                 \
1159       o = gc##base##_pywrap((/*unconst*/ gc##base *)g##base##tab[i]);   \
1160       PyDict_SetItemString(d,                                           \
1161                            (/*unconst*/ char *)g##base##tab[i]->name,   \
1162                            o);                                          \
1163       Py_DECREF(o);                                                     \
1164     }                                                                   \
1165     return (d);                                                         \
1166   }
1167 GEN(gcciphers, cipher)
1168 GEN(gchashes, hash)
1169 GEN(gcmacs, mac)
1170
1171 void algorithms_pyinsert(PyObject *mod)
1172 {
1173   PyObject *d;
1174   INSERT("KeySZ", keysz_pytype);
1175   INSERT("KeySZAny", keyszany_pytype);
1176   INSERT("KeySZRange", keyszrange_pytype);
1177   INSERT("KeySZSet", keyszset_pytype);
1178   INSERT("GCCipher", gccipher_pytype);
1179   INSERT("GCipher", gcipher_pytype);
1180   INSERT("gcciphers", gcciphers());
1181   INSERT("GCHash", gchash_pytype);
1182   INSERT("GHash", ghash_pytype);
1183   INSERT("gchashes", d = gchashes());
1184   sha_pyobj = PyDict_GetItemString(d, "sha"); Py_INCREF(sha_pyobj);
1185   has160_pyobj = PyDict_GetItemString(d, "has160"); Py_INCREF(has160_pyobj);
1186   INSERT("GCMAC", gcmac_pytype);
1187   INSERT("GMAC", gmac_pytype);
1188   INSERT("GMACHash", gmhash_pytype);
1189   INSERT("gcmacs", gcmacs());
1190 }
1191
1192 /*----- That's all, folks -------------------------------------------------*/