3 * Symmetric cryptography
5 * (c) 2004 Straylight/Edgeware
8 /*----- Licensing notice --------------------------------------------------*
10 * This file is part of the Python interface to Catacomb.
12 * Catacomb/Python is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * Catacomb/Python is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with Catacomb/Python; if not, write to the Free Software Foundation,
24 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27 /*----- Header files ------------------------------------------------------*/
29 #include "catacomb-python.h"
30 #include "algorithms.h"
32 /*----- Key sizes ---------------------------------------------------------*/
34 PyTypeObject
*keysz_pytype
;
35 PyTypeObject
*keyszany_pytype
, *keyszrange_pytype
, *keyszset_pytype
;
36 PyObject
*sha_pyobj
, *has160_pyobj
;
38 PyObject
*keysz_pywrap(const octet
*k
)
42 keysz_pyobj
*o
= PyObject_New(keysz_pyobj
, keyszany_pytype
);
44 return ((PyObject
*)o
);
48 PyObject_New(keyszrange_pyobj
, keyszrange_pytype
);
53 if (!o
->mod
) o
->mod
= 1;
54 return ((PyObject
*)o
);
58 PyObject_New(keyszset_pyobj
, keyszset_pytype
);
61 for (i
= 0; k
[i
+ 1]; i
++) ;
62 n
= i
; o
->set
= PyTuple_New(n
);
63 for (i
= 0; i
< n
; i
++)
64 PyTuple_SET_ITEM(o
->set
, i
, PyInt_FromLong(k
[i
+ 1]));
65 return ((PyObject
*)o
);
72 static PyObject
*keyszany_pynew(PyTypeObject
*ty
,
73 PyObject
*arg
, PyObject
*kw
)
75 char *kwlist
[] = { "default", 0 };
79 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "i:new", kwlist
, &dfl
))
81 if (dfl
< 0) VALERR("key size cannot be negative");
82 o
= (keysz_pyobj
*)ty
->tp_alloc(ty
, 0);
84 return ((PyObject
*)o
);
89 static PyObject
*keyszrange_pynew(PyTypeObject
*ty
,
90 PyObject
*arg
, PyObject
*kw
)
92 char *kwlist
[] = { "default", "min", "max", "mod", 0 };
93 int dfl
, min
= 0, max
= 0, mod
= 1;
96 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "i|iii:new", kwlist
,
97 &dfl
, &min
, &max
, &mod
))
99 if (dfl
< 0 || min
< 0 || max
< 0)
100 VALERR("key size cannot be negative");
101 if (min
> dfl
|| (max
&& dfl
> max
))
102 VALERR("bad key size bounds");
103 if (mod
<= 0 || dfl
% mod
|| min
% mod
|| max
% mod
)
104 VALERR("bad key size modulus");
105 o
= (keyszrange_pyobj
*)ty
->tp_alloc(ty
, 0);
110 return ((PyObject
*)o
);
115 static PyObject
*keyszset_pynew(PyTypeObject
*ty
,
116 PyObject
*arg
, PyObject
*kw
)
118 char *kwlist
[] = { "default", "set", 0 };
121 PyObject
*x
= 0, *l
= 0;
122 keyszset_pyobj
*o
= 0;
124 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "i|O:new", kwlist
,
127 if (!set
) set
= PyTuple_New(0);
129 if (!PySequence_Check(set
)) TYERR("want a sequence");
130 n
= PySequence_Size(set
);
132 if (PyErr_Occurred()) goto end
;
133 if (dfl
< 0) VALERR("key size cannot be negative");
134 x
= PyInt_FromLong(dfl
);
138 for (i
= 0; i
< n
; i
++) {
139 if ((x
= PySequence_GetItem(set
, i
)) == 0) goto end
;
140 xx
= PyInt_AsLong(x
);
141 if (PyErr_Occurred()) goto end
;
142 if (xx
== dfl
) continue;
143 if (xx
< 0) VALERR("key size cannot be negative");
149 if ((set
= PySequence_Tuple(l
)) == 0) goto end
;
150 o
= (keyszset_pyobj
*)ty
->tp_alloc(ty
, 0);
158 return ((PyObject
*)o
);
161 static PyObject
*kaget_min(PyObject
*me
, void *hunoz
)
162 { return (PyInt_FromLong(0)); }
163 #define kaget_max kaget_min
165 static PyObject
*ksget_min(PyObject
*me
, void *hunoz
)
167 PyObject
*set
= ((keyszset_pyobj
*)me
)->set
;
169 n
= PyTuple_Size(set
);
170 for (i
= 0; i
< n
; i
++) {
171 y
= PyInt_AsLong(PyTuple_GetItem(set
, i
));
172 if (x
== -1 || y
< x
) x
= y
;
174 return (PyInt_FromLong(x
));
177 static PyObject
*ksget_max(PyObject
*me
, void *hunoz
)
179 PyObject
*set
= ((keyszset_pyobj
*)me
)->set
;
181 n
= PyTuple_Size(set
);
182 for (i
= 0; i
< n
; i
++) {
183 y
= PyInt_AsLong(PyTuple_GetItem(set
, i
));
186 return (PyInt_FromLong(x
));
189 static PyMemberDef keysz_pymembers
[] = {
190 #define MEMBERSTRUCT keysz_pyobj
191 #define default dfl /* ugh! */
192 MEMBER(default, T_INT
, READONLY
, "KSZ.default -> default key size")
198 static PyGetSetDef keyszany_pygetset
[] = {
199 #define GETSETNAME(op, name) ka##op##_##name
200 GET (min
, "KSZ.min -> smallest allowed key size")
201 GET (max
, "KSZ.min -> largest allowed key size")
206 static PyMemberDef keyszrange_pymembers
[] = {
207 #define MEMBERSTRUCT keyszrange_pyobj
208 MEMBER(min
, T_INT
, READONLY
, "KSZ.min -> smallest allowed key size")
209 MEMBER(max
, T_INT
, READONLY
, "KSZ.min -> largest allowed key size")
210 MEMBER(mod
, T_INT
, READONLY
,
211 "KSZ.mod -> key size must be a multiple of this")
216 static PyGetSetDef keyszset_pygetset
[] = {
217 #define GETSETNAME(op, name) ks##op##_##name
218 GET (min
, "KSZ.min -> smallest allowed key size")
219 GET (max
, "KSZ.min -> largest allowed key size")
224 static PyMemberDef keyszset_pymembers
[] = {
225 #define MEMBERSTRUCT keyszset_pyobj
226 MEMBER(set
, T_OBJECT
, READONLY
, "KSZ.set -> allowed key sizes")
231 static PyTypeObject keysz_pytype_skel
= {
232 PyObject_HEAD_INIT(0) 0, /* Header */
233 "KeySZ", /* @tp_name@ */
234 sizeof(keysz_pyobj
), /* @tp_basicsize@ */
235 0, /* @tp_itemsize@ */
237 0, /* @tp_dealloc@ */
239 0, /* @tp_getattr@ */
240 0, /* @tp_setattr@ */
241 0, /* @tp_compare@ */
243 0, /* @tp_as_number@ */
244 0, /* @tp_as_sequence@ */
245 0, /* @tp_as_mapping@ */
249 0, /* @tp_getattro@ */
250 0, /* @tp_setattro@ */
251 0, /* @tp_as_buffer@ */
252 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
256 "Key size constraints.",
258 0, /* @tp_traverse@ */
260 0, /* @tp_richcompare@ */
261 0, /* @tp_weaklistoffset@ */
263 0, /* @tp_iternext@ */
264 0, /* @tp_methods@ */
265 keysz_pymembers
, /* @tp_members@ */
269 0, /* @tp_descr_get@ */
270 0, /* @tp_descr_set@ */
271 0, /* @tp_dictoffset@ */
273 PyType_GenericAlloc
, /* @tp_alloc@ */
274 abstract_pynew
, /* @tp_new@ */
279 static PyTypeObject keyszany_pytype_skel
= {
280 PyObject_HEAD_INIT(0) 0, /* Header */
281 "KeySZAny", /* @tp_name@ */
282 sizeof(keysz_pyobj
), /* @tp_basicsize@ */
283 0, /* @tp_itemsize@ */
285 0, /* @tp_dealloc@ */
287 0, /* @tp_getattr@ */
288 0, /* @tp_setattr@ */
289 0, /* @tp_compare@ */
291 0, /* @tp_as_number@ */
292 0, /* @tp_as_sequence@ */
293 0, /* @tp_as_mapping@ */
297 0, /* @tp_getattro@ */
298 0, /* @tp_setattro@ */
299 0, /* @tp_as_buffer@ */
300 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
304 "Key size constraints. This object imposes no constraints on size.",
306 0, /* @tp_traverse@ */
308 0, /* @tp_richcompare@ */
309 0, /* @tp_weaklistoffset@ */
311 0, /* @tp_iternext@ */
312 0, /* @tp_methods@ */
313 0, /* @tp_members@ */
314 keyszany_pygetset
, /* @tp_getset@ */
317 0, /* @tp_descr_get@ */
318 0, /* @tp_descr_set@ */
319 0, /* @tp_dictoffset@ */
321 PyType_GenericAlloc
, /* @tp_alloc@ */
322 keyszany_pynew
, /* @tp_new@ */
327 static PyTypeObject keyszrange_pytype_skel
= {
328 PyObject_HEAD_INIT(0) 0, /* Header */
329 "KeySZRange", /* @tp_name@ */
330 sizeof(keyszrange_pyobj
), /* @tp_basicsize@ */
331 0, /* @tp_itemsize@ */
333 0, /* @tp_dealloc@ */
335 0, /* @tp_getattr@ */
336 0, /* @tp_setattr@ */
337 0, /* @tp_compare@ */
339 0, /* @tp_as_number@ */
340 0, /* @tp_as_sequence@ */
341 0, /* @tp_as_mapping@ */
345 0, /* @tp_getattro@ */
346 0, /* @tp_setattro@ */
347 0, /* @tp_as_buffer@ */
348 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
352 "Key size constraints. This object asserts minimum and maximum (if\n\
353 sizes, and requires the key length to be a multiple of some value.",
355 0, /* @tp_traverse@ */
357 0, /* @tp_richcompare@ */
358 0, /* @tp_weaklistoffset@ */
360 0, /* @tp_iternext@ */
361 0, /* @tp_methods@ */
362 keyszrange_pymembers
, /* @tp_members@ */
366 0, /* @tp_descr_get@ */
367 0, /* @tp_descr_set@ */
368 0, /* @tp_dictoffset@ */
370 PyType_GenericAlloc
, /* @tp_alloc@ */
371 keyszrange_pynew
, /* @tp_new@ */
376 static PyTypeObject keyszset_pytype_skel
= {
377 PyObject_HEAD_INIT(0) 0, /* Header */
378 "KeySZSet", /* @tp_name@ */
379 sizeof(keyszset_pyobj
), /* @tp_basicsize@ */
380 0, /* @tp_itemsize@ */
382 0, /* @tp_dealloc@ */
384 0, /* @tp_getattr@ */
385 0, /* @tp_setattr@ */
386 0, /* @tp_compare@ */
388 0, /* @tp_as_number@ */
389 0, /* @tp_as_sequence@ */
390 0, /* @tp_as_mapping@ */
394 0, /* @tp_getattro@ */
395 0, /* @tp_setattro@ */
396 0, /* @tp_as_buffer@ */
397 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
401 "Key size constraints. This object requires the key to be one of a\n\
404 0, /* @tp_traverse@ */
406 0, /* @tp_richcompare@ */
407 0, /* @tp_weaklistoffset@ */
409 0, /* @tp_iternext@ */
410 0, /* @tp_methods@ */
411 keyszset_pymembers
, /* @tp_members@ */
412 keyszset_pygetset
, /* @tp_getset@ */
415 0, /* @tp_descr_get@ */
416 0, /* @tp_descr_set@ */
417 0, /* @tp_dictoffset@ */
419 PyType_GenericAlloc
, /* @tp_alloc@ */
420 keyszset_pynew
, /* @tp_new@ */
425 #define KSZCONVOP(op) \
426 static PyObject *meth__KeySZ_##op(PyObject *me, PyObject *arg) \
429 if (!PyArg_ParseTuple(arg, "Od:" #op, &me, &x)) return (0); \
431 return (PyFloat_FromDouble(y)); \
434 KSZCONVOP(fromschnorr
)
443 /*----- Symmetric encryption ----------------------------------------------*/
445 PyTypeObject
*gccipher_pytype
, *gcipher_pytype
;
447 CONVFUNC(gccipher
, gccipher
*, GCCIPHER_CC
)
448 CONVFUNC(gcipher
, gcipher
*, GCIPHER_C
)
450 PyObject
*gcipher_pywrap(PyObject
*cobj
, gcipher
*c
, unsigned f
)
453 if (!cobj
) cobj
= gccipher_pywrap((/*unconst*/ gccipher
*)GC_CLASS(c
));
454 else Py_INCREF(cobj
);
455 g
= PyObject_NEW(gcipher_pyobj
, (PyTypeObject
*)cobj
);
458 return ((PyObject
*)g
);
461 static PyObject
*gcipher_pynew(PyTypeObject
*ty
, PyObject
*arg
, PyObject
*kw
)
463 char *kwlist
[] = { "k", 0 };
467 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "s#:new", kwlist
, &k
, &sz
))
469 if (keysz(sz
, GCCIPHER_CC(ty
)->keysz
) != sz
) VALERR("bad key length");
470 return (gcipher_pywrap((PyObject
*)ty
,
471 GC_INIT(GCCIPHER_CC(ty
), k
, sz
),
477 PyObject
*gccipher_pywrap(gccipher
*cc
)
479 gccipher_pyobj
*g
= newtype(gccipher_pytype
, 0, cc
->name
);
481 g
->ty
.ht_type
.tp_basicsize
= sizeof(gcipher_pyobj
);
482 g
->ty
.ht_type
.tp_base
= gcipher_pytype
;
483 Py_INCREF(gcipher_pytype
);
484 g
->ty
.ht_type
.tp_flags
= (Py_TPFLAGS_DEFAULT
|
485 Py_TPFLAGS_BASETYPE
|
486 Py_TPFLAGS_HEAPTYPE
);
487 g
->ty
.ht_type
.tp_alloc
= PyType_GenericAlloc
;
488 g
->ty
.ht_type
.tp_free
= 0;
489 g
->ty
.ht_type
.tp_new
= gcipher_pynew
;
490 typeready(&g
->ty
.ht_type
);
491 return ((PyObject
*)g
);
494 static void gcipher_pydealloc(PyObject
*me
)
496 if (GCIPHER_F(me
) & f_freeme
)
497 GC_DESTROY(GCIPHER_C(me
));
498 Py_DECREF(me
->ob_type
);
502 static PyObject
*gccget_name(PyObject
*me
, void *hunoz
)
503 { return (PyString_FromString(GCCIPHER_CC(me
)->name
)); }
505 static PyObject
*gccget_keysz(PyObject
*me
, void *hunoz
)
506 { return (keysz_pywrap(GCCIPHER_CC(me
)->keysz
)); }
508 static PyObject
*gccget_blksz(PyObject
*me
, void *hunoz
)
509 { return (PyInt_FromLong(GCCIPHER_CC(me
)->blksz
)); }
511 static PyObject
*gcmeth_encrypt(PyObject
*me
, PyObject
*arg
)
517 if (!PyArg_ParseTuple(arg
, "s#:encrypt", &p
, &sz
)) return (0);
518 rc
= bytestring_pywrap(0, sz
);
519 GC_ENCRYPT(GCIPHER_C(me
), p
, PyString_AS_STRING(rc
), sz
);
523 static PyObject
*gcmeth_enczero(PyObject
*me
, PyObject
*arg
)
529 if (!PyArg_ParseTuple(arg
, "i:enczero", &sz
)) return (0);
530 rc
= bytestring_pywrap(0, sz
);
531 p
= PyString_AS_STRING(rc
);
533 GC_ENCRYPT(GCIPHER_C(me
), p
, p
, sz
);
537 static PyObject
*gcmeth_decrypt(PyObject
*me
, PyObject
*arg
)
543 if (!PyArg_ParseTuple(arg
, "s#:decrypt", &p
, &sz
)) return (0);
544 rc
= bytestring_pywrap(0, sz
);
545 GC_DECRYPT(GCIPHER_C(me
), p
, PyString_AS_STRING(rc
), sz
);
549 static PyObject
*gcmeth_deczero(PyObject
*me
, PyObject
*arg
)
555 if (!PyArg_ParseTuple(arg
, "i:deczero", &sz
)) return (0);
556 rc
= bytestring_pywrap(0, sz
);
557 p
= PyString_AS_STRING(rc
);
559 GC_DECRYPT(GCIPHER_C(me
), p
, p
, sz
);
563 static PyObject
*gcmeth_setiv(PyObject
*me
, PyObject
*arg
)
568 if (!PyArg_ParseTuple(arg
, "s#:setiv", &p
, &sz
)) goto end
;
569 if (!GC_CLASS(GCIPHER_C(me
))->blksz
) VALERR("not a block cipher mode");
570 if (sz
!= GC_CLASS(GCIPHER_C(me
))->blksz
) VALERR("bad IV length");
571 GC_SETIV(GCIPHER_C(me
), p
);
577 static PyObject
*gcmeth_bdry(PyObject
*me
, PyObject
*arg
)
579 if (!PyArg_ParseTuple(arg
, ":bdry")) goto end
;
580 if (!GC_CLASS(GCIPHER_C(me
))->blksz
) VALERR("not a block cipher mode");
581 GC_BDRY(GCIPHER_C(me
));
587 static PyGetSetDef gccipher_pygetset
[] = {
588 #define GETSETNAME(op, name) gcc##op##_##name
589 GET (keysz
, "CC.keysz -> acceptable key sizes")
590 GET (blksz
, "CC.blksz -> block size, or zero")
591 GET (name
, "CC.name -> name of this kind of cipher")
596 static PyMethodDef gcipher_pymethods
[] = {
597 #define METHNAME(name) gcmeth_##name
598 METH (encrypt
, "C.encrypt(PT) -> CT")
599 METH (enczero
, "C.enczero(N) -> CT")
600 METH (decrypt
, "C.decrypt(CT) -> PT")
601 METH (deczero
, "C.deczero(N) -> PT")
602 METH (setiv
, "C.setiv(IV)")
603 METH (bdry
, "C.bdry()")
608 static PyTypeObject gccipher_pytype_skel
= {
609 PyObject_HEAD_INIT(0) 0, /* Header */
610 "GCCipher", /* @tp_name@ */
611 sizeof(gccipher_pyobj
), /* @tp_basicsize@ */
612 0, /* @tp_itemsize@ */
614 0, /* @tp_dealloc@ */
616 0, /* @tp_getattr@ */
617 0, /* @tp_setattr@ */
618 0, /* @tp_compare@ */
620 0, /* @tp_as_number@ */
621 0, /* @tp_as_sequence@ */
622 0, /* @tp_as_mapping@ */
626 0, /* @tp_getattro@ */
627 0, /* @tp_setattro@ */
628 0, /* @tp_as_buffer@ */
629 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
633 "Symmetric cipher metaclass.",
635 0, /* @tp_traverse@ */
637 0, /* @tp_richcompare@ */
638 0, /* @tp_weaklistoffset@ */
640 0, /* @tp_iternext@ */
641 0, /* @tp_methods@ */
642 0, /* @tp_members@ */
643 gccipher_pygetset
, /* @tp_getset@ */
646 0, /* @tp_descr_get@ */
647 0, /* @tp_descr_set@ */
648 0, /* @tp_dictoffset@ */
650 PyType_GenericAlloc
, /* @tp_alloc@ */
651 abstract_pynew
, /* @tp_new@ */
656 static PyTypeObject gcipher_pytype_skel
= {
657 PyObject_HEAD_INIT(0) 0, /* Header */
658 "GCipher", /* @tp_name@ */
659 sizeof(gcipher_pyobj
), /* @tp_basicsize@ */
660 0, /* @tp_itemsize@ */
662 gcipher_pydealloc
, /* @tp_dealloc@ */
664 0, /* @tp_getattr@ */
665 0, /* @tp_setattr@ */
666 0, /* @tp_compare@ */
668 0, /* @tp_as_number@ */
669 0, /* @tp_as_sequence@ */
670 0, /* @tp_as_mapping@ */
674 0, /* @tp_getattro@ */
675 0, /* @tp_setattro@ */
676 0, /* @tp_as_buffer@ */
677 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
681 "Symmetric cipher, abstract base class.",
683 0, /* @tp_traverse@ */
685 0, /* @tp_richcompare@ */
686 0, /* @tp_weaklistoffset@ */
688 0, /* @tp_iternext@ */
689 gcipher_pymethods
, /* @tp_methods@ */
690 0, /* @tp_members@ */
694 0, /* @tp_descr_get@ */
695 0, /* @tp_descr_set@ */
696 0, /* @tp_dictoffset@ */
698 PyType_GenericAlloc
, /* @tp_alloc@ */
699 abstract_pynew
, /* @tp_new@ */
704 /*----- Hash functions ----------------------------------------------------*/
706 PyTypeObject
*gchash_pytype
, *ghash_pytype
;
708 CONVFUNC(gchash
, gchash
*, GCHASH_CH
)
709 CONVFUNC(ghash
, ghash
*, GHASH_H
)
711 static PyObject
*ghash_pynew(PyTypeObject
*ty
, PyObject
*arg
, PyObject
*kw
)
713 char *kwlist
[] = { 0 };
714 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, ":new", kwlist
))
716 return (ghash_pywrap((PyObject
*)ty
, GH_INIT(GCHASH_CH(ty
)), f_freeme
));
721 PyObject
*gchash_pywrap(gchash
*ch
)
723 gchash_pyobj
*g
= newtype(gchash_pytype
, 0, ch
->name
);
725 g
->ty
.ht_type
.tp_basicsize
= sizeof(ghash_pyobj
);
726 g
->ty
.ht_type
.tp_base
= ghash_pytype
;
727 Py_INCREF(ghash_pytype
);
728 g
->ty
.ht_type
.tp_flags
= (Py_TPFLAGS_DEFAULT
|
729 Py_TPFLAGS_BASETYPE
|
730 Py_TPFLAGS_HEAPTYPE
);
731 g
->ty
.ht_type
.tp_alloc
= PyType_GenericAlloc
;
732 g
->ty
.ht_type
.tp_free
= 0;
733 g
->ty
.ht_type
.tp_new
= ghash_pynew
;
734 typeready(&g
->ty
.ht_type
);
735 return ((PyObject
*)g
);
738 PyObject
*ghash_pywrap(PyObject
*cobj
, ghash
*h
, unsigned f
)
741 if (!cobj
) cobj
= gchash_pywrap((/*unconst*/ gchash
*)GH_CLASS(h
));
742 else Py_INCREF(cobj
);
743 g
= PyObject_NEW(ghash_pyobj
, (PyTypeObject
*)cobj
);
746 return ((PyObject
*)g
);
749 static void ghash_pydealloc(PyObject
*me
)
751 if (GHASH_F(me
) & f_freeme
)
752 GH_DESTROY(GHASH_H(me
));
753 Py_DECREF(me
->ob_type
);
757 static PyObject
*gchget_name(PyObject
*me
, void *hunoz
)
758 { return (PyString_FromString(GCHASH_CH(me
)->name
)); }
760 static PyObject
*gchget_hashsz(PyObject
*me
, void *hunoz
)
761 { return (PyInt_FromLong(GCHASH_CH(me
)->hashsz
)); }
763 static PyObject
*gchget_bufsz(PyObject
*me
, void *hunoz
)
764 { return (PyInt_FromLong(GCHASH_CH(me
)->bufsz
)); }
766 static PyObject
*ghmeth_hash(PyObject
*me
, PyObject
*arg
)
770 if (!PyArg_ParseTuple(arg
, "s#:hash", &p
, &sz
)) return (0);
771 GH_HASH(GHASH_H(me
), p
, sz
);
775 static PyObject
*ghmeth_done(PyObject
*me
, PyObject
*arg
)
779 if (!PyArg_ParseTuple(arg
, ":done")) return (0);
780 g
= GH_COPY(GHASH_H(me
));
781 rc
= bytestring_pywrap(0, g
->ops
->c
->hashsz
);
782 GH_DONE(g
, PyString_AS_STRING(rc
));
787 static PyGetSetDef gchash_pygetset
[] = {
788 #define GETSETNAME(op, name) gch##op##_##name
789 GET (bufsz
, "CH.bufsz -> hash buffer size, or zero")
790 GET (hashsz
, "CH.hashsz -> hash output size")
791 GET (name
, "CH.name -> name of this kind of hash")
796 #define GHMETH_HASHU_(n, W, w) \
797 static PyObject *ghmeth_hashu##w(PyObject *me, PyObject *arg) \
800 if (!PyArg_ParseTuple(arg, "O&:hashu" #w, convu##n, &x)) goto end; \
801 GH_HASHU##W(GHASH_H(me), x); \
806 DOUINTCONV(GHMETH_HASHU_
)
808 #define GHMETH_HASHBUF_(n, W, w) \
809 static PyObject *ghmeth_hashbuf##w(PyObject *me, PyObject *arg) \
813 if (!PyArg_ParseTuple(arg, "s#:hashbuf" #w, &p, &sz)) goto end; \
814 if (sz > MASK##n) TYERR("string too long"); \
815 GH_HASHBUF##W(GHASH_H(me), p, sz); \
820 DOUINTCONV(GHMETH_HASHBUF_
)
822 static PyObject
*ghmeth_hashstrz(PyObject
*me
, PyObject
*arg
)
825 if (!PyArg_ParseTuple(arg
, "s:hashstrz", &p
)) return (0);
826 GH_HASHSTRZ(GHASH_H(me
), p
);
830 static PyMethodDef ghash_pymethods
[] = {
831 #define METHNAME(name) ghmeth_##name
832 METH (hash
, "H.hash(M)")
833 #define METHU_(n, W, w) METH(hashu##w, "H.hashu" #w "(WORD)")
835 #define METHBUF_(n, W, w) METH(hashbuf##w, "H.hashbuf" #w "(BYTES)")
837 METH (hashstrz
, "H.hashstrz(STRING)")
838 METH (done
, "H.done() -> HASH")
843 static PyTypeObject gchash_pytype_skel
= {
844 PyObject_HEAD_INIT(0) 0, /* Header */
845 "GCHash", /* @tp_name@ */
846 sizeof(gchash_pyobj
), /* @tp_basicsize@ */
847 0, /* @tp_itemsize@ */
849 0, /* @tp_dealloc@ */
851 0, /* @tp_getattr@ */
852 0, /* @tp_setattr@ */
853 0, /* @tp_compare@ */
855 0, /* @tp_as_number@ */
856 0, /* @tp_as_sequence@ */
857 0, /* @tp_as_mapping@ */
861 0, /* @tp_getattro@ */
862 0, /* @tp_setattro@ */
863 0, /* @tp_as_buffer@ */
864 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
868 "Hash function metaclass.",
870 0, /* @tp_traverse@ */
872 0, /* @tp_richcompare@ */
873 0, /* @tp_weaklistoffset@ */
875 0, /* @tp_iternext@ */
876 0, /* @tp_methods@ */
877 0, /* @tp_members@ */
878 gchash_pygetset
, /* @tp_getset@ */
881 0, /* @tp_descr_get@ */
882 0, /* @tp_descr_set@ */
883 0, /* @tp_dictoffset@ */
885 PyType_GenericAlloc
, /* @tp_alloc@ */
886 abstract_pynew
, /* @tp_new@ */
891 static PyTypeObject ghash_pytype_skel
= {
892 PyObject_HEAD_INIT(0) 0, /* Header */
893 "GHash", /* @tp_name@ */
894 sizeof(ghash_pyobj
), /* @tp_basicsize@ */
895 0, /* @tp_itemsize@ */
897 ghash_pydealloc
, /* @tp_dealloc@ */
899 0, /* @tp_getattr@ */
900 0, /* @tp_setattr@ */
901 0, /* @tp_compare@ */
903 0, /* @tp_as_number@ */
904 0, /* @tp_as_sequence@ */
905 0, /* @tp_as_mapping@ */
909 0, /* @tp_getattro@ */
910 0, /* @tp_setattro@ */
911 0, /* @tp_as_buffer@ */
912 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
916 "Hash function, abstract base class.",
918 0, /* @tp_traverse@ */
920 0, /* @tp_richcompare@ */
921 0, /* @tp_weaklistoffset@ */
923 0, /* @tp_iternext@ */
924 ghash_pymethods
, /* @tp_methods@ */
925 0, /* @tp_members@ */
929 0, /* @tp_descr_get@ */
930 0, /* @tp_descr_set@ */
931 0, /* @tp_dictoffset@ */
933 PyType_GenericAlloc
, /* @tp_alloc@ */
934 abstract_pynew
, /* @tp_new@ */
939 /*----- Message authentication --------------------------------------------*/
941 PyTypeObject
*gcmac_pytype
, *gmac_pytype
, *gmhash_pytype
;
943 CONVFUNC(gcmac
, gcmac
*, GCMAC_CM
)
944 CONVFUNC(gmac
, gmac
*, GMAC_M
)
945 CONVFUNC(gmhash
, ghash
*, GHASH_H
)
947 static PyObject
*gmac_pynew(PyTypeObject
*ty
, PyObject
*arg
, PyObject
*kw
)
949 char *kwlist
[] = { "k", 0 };
953 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "s#:new", kwlist
, &k
, &sz
))
955 if (keysz(sz
, GCMAC_CM(ty
)->keysz
) != sz
) VALERR("bad key length");
956 return (gmac_pywrap((PyObject
*)ty
,
957 GM_KEY(GCMAC_CM(ty
), k
, sz
),
963 static PyObject
*gmhash_pynew(PyTypeObject
*ty
, PyObject
*arg
, PyObject
*kw
)
965 char *kwlist
[] = { 0 };
968 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, ":new", kwlist
)) return (0);
969 g
= PyObject_NEW(ghash_pyobj
, ty
);
970 g
->h
= GM_INIT(GMAC_M(ty
));
973 return ((PyObject
*)g
);
976 PyObject
*gcmac_pywrap(gcmac
*cm
)
978 gcmac_pyobj
*g
= newtype(gcmac_pytype
, 0, cm
->name
);
980 g
->ty
.ht_type
.tp_basicsize
= sizeof(gmac_pyobj
);
981 g
->ty
.ht_type
.tp_base
= gmac_pytype
;
982 Py_INCREF(gmac_pytype
);
983 g
->ty
.ht_type
.tp_flags
= (Py_TPFLAGS_DEFAULT
|
984 Py_TPFLAGS_BASETYPE
|
985 Py_TPFLAGS_HEAPTYPE
);
986 g
->ty
.ht_type
.tp_alloc
= PyType_GenericAlloc
;
987 g
->ty
.ht_type
.tp_free
= 0;
988 g
->ty
.ht_type
.tp_new
= gmac_pynew
;
989 typeready(&g
->ty
.ht_type
);
990 return ((PyObject
*)g
);
993 PyObject
*gmac_pywrap(PyObject
*cobj
, gmac
*m
, unsigned f
)
996 if (!cobj
) cobj
= gcmac_pywrap((/*unconst*/ gcmac
*)GM_CLASS(m
));
997 else Py_INCREF(cobj
);
998 g
= newtype((PyTypeObject
*)cobj
, 0, 0);
999 g
->ty
.ht_type
.tp_basicsize
= sizeof(ghash_pyobj
);
1000 g
->ty
.ht_name
= PyString_FromFormat("%s(keyed)", m
->ops
->c
->name
);
1001 g
->ty
.ht_type
.tp_name
= PyString_AS_STRING(g
->ty
.ht_name
);
1002 g
->ty
.ht_type
.tp_base
= gmhash_pytype
;
1003 Py_INCREF(gmac_pytype
);
1004 g
->ty
.ht_type
.tp_flags
= (Py_TPFLAGS_DEFAULT
|
1005 Py_TPFLAGS_BASETYPE
|
1006 Py_TPFLAGS_HEAPTYPE
);
1007 g
->ty
.ht_type
.tp_alloc
= PyType_GenericAlloc
;
1008 g
->ty
.ht_type
.tp_free
= 0;
1009 g
->ty
.ht_type
.tp_new
= gmhash_pynew
;
1010 typeready(&g
->ty
.ht_type
);
1013 return ((PyObject
*)g
);
1016 static void gmac_pydealloc(PyObject
*me
)
1018 if (GMAC_F(me
) & f_freeme
)
1019 GM_DESTROY(GMAC_M(me
));
1020 Py_DECREF(me
->ob_type
);
1021 PyType_Type
.tp_dealloc(me
);
1024 static PyObject
*gcmget_name(PyObject
*me
, void *hunoz
)
1025 { return (PyString_FromString(GCMAC_CM(me
)->name
)); }
1027 static PyObject
*gcmget_keysz(PyObject
*me
, void *hunoz
)
1028 { return (keysz_pywrap(GCMAC_CM(me
)->keysz
)); }
1030 static PyObject
*gcmget_tagsz(PyObject
*me
, void *hunoz
)
1031 { return (PyInt_FromLong(GCMAC_CM(me
)->hashsz
)); }
1033 static PyGetSetDef gcmac_pygetset
[] = {
1034 #define GETSETNAME(op, name) gcm##op##_##name
1035 GET (keysz
, "CM.keysz -> acceptable key sizes")
1036 GET (tagsz
, "CM.tagsz -> MAC output size")
1037 GET (name
, "CM.name -> name of this kind of MAC")
1042 static PyTypeObject gcmac_pytype_skel
= {
1043 PyObject_HEAD_INIT(0) 0, /* Header */
1044 "GCMAC", /* @tp_name@ */
1045 sizeof(gchash_pyobj
), /* @tp_basicsize@ */
1046 0, /* @tp_itemsize@ */
1048 0, /* @tp_dealloc@ */
1050 0, /* @tp_getattr@ */
1051 0, /* @tp_setattr@ */
1052 0, /* @tp_compare@ */
1054 0, /* @tp_as_number@ */
1055 0, /* @tp_as_sequence@ */
1056 0, /* @tp_as_mapping@ */
1060 0, /* @tp_getattro@ */
1061 0, /* @tp_setattro@ */
1062 0, /* @tp_as_buffer@ */
1063 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1064 Py_TPFLAGS_BASETYPE
,
1067 "Message authentication code metametaclass.",
1069 0, /* @tp_traverse@ */
1071 0, /* @tp_richcompare@ */
1072 0, /* @tp_weaklistoffset@ */
1074 0, /* @tp_iternext@ */
1075 0, /* @tp_methods@ */
1076 0, /* @tp_members@ */
1077 gcmac_pygetset
, /* @tp_getset@ */
1080 0, /* @tp_descr_get@ */
1081 0, /* @tp_descr_set@ */
1082 0, /* @tp_dictoffset@ */
1084 PyType_GenericAlloc
, /* @tp_alloc@ */
1085 abstract_pynew
, /* @tp_new@ */
1090 static PyTypeObject gmac_pytype_skel
= {
1091 PyObject_HEAD_INIT(0) 0, /* Header */
1092 "GMAC", /* @tp_name@ */
1093 sizeof(gmac_pyobj
), /* @tp_basicsize@ */
1094 0, /* @tp_itemsize@ */
1096 gmac_pydealloc
, /* @tp_dealloc@ */
1098 0, /* @tp_getattr@ */
1099 0, /* @tp_setattr@ */
1100 0, /* @tp_compare@ */
1102 0, /* @tp_as_number@ */
1103 0, /* @tp_as_sequence@ */
1104 0, /* @tp_as_mapping@ */
1108 0, /* @tp_getattro@ */
1109 0, /* @tp_setattro@ */
1110 0, /* @tp_as_buffer@ */
1111 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1112 Py_TPFLAGS_BASETYPE
,
1115 "Message authentication code metaclass, abstract base class.",
1117 0, /* @tp_traverse@ */
1119 0, /* @tp_richcompare@ */
1120 0, /* @tp_weaklistoffset@ */
1122 0, /* @tp_iternext@ */
1123 0, /* @tp_methods@ */
1124 0, /* @tp_members@ */
1125 0, /* @tp_getset@ */
1128 0, /* @tp_descr_get@ */
1129 0, /* @tp_descr_set@ */
1130 0, /* @tp_dictoffset@ */
1132 PyType_GenericAlloc
, /* @tp_alloc@ */
1133 abstract_pynew
, /* @tp_new@ */
1138 static PyTypeObject gmhash_pytype_skel
= {
1139 PyObject_HEAD_INIT(0) 0, /* Header */
1140 "GMACHash", /* @tp_name@ */
1141 sizeof(ghash_pyobj
), /* @tp_basicsize@ */
1142 0, /* @tp_itemsize@ */
1144 ghash_pydealloc
, /* @tp_dealloc@ */
1146 0, /* @tp_getattr@ */
1147 0, /* @tp_setattr@ */
1148 0, /* @tp_compare@ */
1150 0, /* @tp_as_number@ */
1151 0, /* @tp_as_sequence@ */
1152 0, /* @tp_as_mapping@ */
1156 0, /* @tp_getattro@ */
1157 0, /* @tp_setattro@ */
1158 0, /* @tp_as_buffer@ */
1159 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1160 Py_TPFLAGS_BASETYPE
,
1163 "Message authentication code, abstract base class.",
1165 0, /* @tp_traverse@ */
1167 0, /* @tp_richcompare@ */
1168 0, /* @tp_weaklistoffset@ */
1170 0, /* @tp_iternext@ */
1171 0, /* @tp_methods@ */
1172 0, /* @tp_members@ */
1173 0, /* @tp_getset@ */
1176 0, /* @tp_descr_get@ */
1177 0, /* @tp_descr_set@ */
1178 0, /* @tp_dictoffset@ */
1180 PyType_GenericAlloc
, /* @tp_alloc@ */
1181 abstract_pynew
, /* @tp_new@ */
1186 /*----- Pseudorandom permutations -----------------------------------------*/
1188 static PyTypeObject
*gcprp_pytype
, *gprp_pytype
;
1190 typedef struct prpinfo
{
1195 void (*init
)(void *, const void *, size_t);
1196 void (*eblk
)(void *, const void *, void *);
1197 void (*dblk
)(void *, const void *, void *);
1200 #define PRP_DEF(PRE, pre) \
1201 static void pre##_prpinit(void *ctx, const void *k, size_t ksz) \
1202 { pre##_init(ctx, k, ksz); } \
1203 static void pre##_prpeblk(void *ctx, const void *in, void *out) \
1205 uint32 w[PRE##_BLKSZ/4]; BLKC_LOAD(PRE, w, in); \
1206 pre##_eblk(ctx, w, w); BLKC_STORE(PRE, out, w); \
1208 static void pre##_prpdblk(void *ctx, const void *in, void *out) \
1210 uint32 w[PRE##_BLKSZ/4]; BLKC_LOAD(PRE, w, in); \
1211 pre##_dblk(ctx, w, w); BLKC_STORE(PRE, out, w); \
1213 static const prpinfo pre##_prpinfo = { \
1214 #pre, pre##_keysz, sizeof(pre##_ctx), PRE##_BLKSZ, \
1215 pre##_prpinit, pre##_prpeblk, pre##_prpdblk \
1219 static const struct prpinfo
*const gprptab
[] = {
1220 #define PRP_ENTRY(PRE, pre) &pre##_prpinfo,
1225 typedef struct gcprp_pyobj
{
1226 PyHeapTypeObject ty
;
1229 #define GCPRP_PRP(o) (((gcprp_pyobj *)(o))->prp)
1231 typedef struct gprp_pyobj
{
1235 #define GPRP_PRP(o) (((gprp_pyobj *)(o))->prp)
1236 #define GPRP_CTX(o) (((gprp_pyobj *)(o)) + 1)
1238 typedef struct prp
{
1243 static PyObject
*gprp_pynew(PyTypeObject
*ty
, PyObject
*arg
, PyObject
*kw
)
1245 char *kwlist
[] = { "key", 0 };
1248 const prpinfo
*prp
= GCPRP_PRP(ty
);
1251 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "s#:new", kwlist
, &k
, &sz
))
1253 if (keysz(sz
, prp
->keysz
) != sz
) VALERR("bad key length");
1254 me
= (PyObject
*)ty
->tp_alloc(ty
, 0);
1256 prp
->init(GPRP_CTX(me
), k
, sz
);
1263 static void gprp_pydealloc(PyObject
*me
)
1264 { Py_DECREF(me
->ob_type
); FREEOBJ(me
); }
1266 static PyObject
*gcprp_pywrap(const prpinfo
*prp
)
1268 gcprp_pyobj
*g
= newtype(gcprp_pytype
, 0, prp
->name
);
1270 g
->ty
.ht_type
.tp_basicsize
= sizeof(gprp_pyobj
) + prp
->ctxsz
;
1271 g
->ty
.ht_type
.tp_base
= gprp_pytype
;
1272 Py_INCREF(gprp_pytype
);
1273 g
->ty
.ht_type
.tp_flags
= (Py_TPFLAGS_DEFAULT
|
1274 Py_TPFLAGS_BASETYPE
|
1275 Py_TPFLAGS_HEAPTYPE
);
1276 g
->ty
.ht_type
.tp_alloc
= PyType_GenericAlloc
;
1277 g
->ty
.ht_type
.tp_free
= 0;
1278 g
->ty
.ht_type
.tp_new
= gprp_pynew
;
1279 typeready(&g
->ty
.ht_type
);
1280 return ((PyObject
*)g
);
1283 static PyObject
*gcpget_name(PyObject
*me
, void *hunoz
)
1284 { return (PyString_FromString(GCPRP_PRP(me
)->name
)); }
1285 static PyObject
*gcpget_keysz(PyObject
*me
, void *hunoz
)
1286 { return (keysz_pywrap(GCPRP_PRP(me
)->keysz
)); }
1287 static PyObject
*gcpget_blksz(PyObject
*me
, void *hunoz
)
1288 { return (PyInt_FromLong(GCPRP_PRP(me
)->blksz
)); }
1290 static PyObject
*gpmeth_encrypt(PyObject
*me
, PyObject
*arg
)
1296 if (!PyArg_ParseTuple(arg
, "s#:encrypt", &p
, &n
)) goto end
;
1297 if (n
!= GPRP_PRP(me
)->blksz
) VALERR("incorrect block length");
1298 rc
= bytestring_pywrap(0, n
);
1299 GPRP_PRP(me
)->eblk(GPRP_CTX(me
), p
, PyString_AS_STRING(rc
));
1304 static PyObject
*gpmeth_decrypt(PyObject
*me
, PyObject
*arg
)
1310 if (!PyArg_ParseTuple(arg
, "s#:decrypt", &p
, &n
)) goto end
;
1311 if (n
!= GPRP_PRP(me
)->blksz
) VALERR("incorrect block length");
1312 rc
= bytestring_pywrap(0, n
);
1313 GPRP_PRP(me
)->dblk(GPRP_CTX(me
), p
, PyString_AS_STRING(rc
));
1318 static PyGetSetDef gcprp_pygetset
[] = {
1319 #define GETSETNAME(op, name) gcp##op##_##name
1320 GET (keysz
, "CP.keysz -> acceptable key sizes")
1321 GET (blksz
, "CP.blksz -> block size")
1322 GET (name
, "CP.name -> name of this kind of PRP")
1327 static PyMethodDef gprp_pymethods
[] = {
1328 #define METHNAME(name) gpmeth_##name
1329 METH (encrypt
, "P.encrypt(PT) -> CT")
1330 METH (decrypt
, "P.decrypt(CT) -> PT")
1335 static PyTypeObject gcprp_pytype_skel
= {
1336 PyObject_HEAD_INIT(0) 0, /* Header */
1337 "GCPRP", /* @tp_name@ */
1338 sizeof(gcprp_pyobj
), /* @tp_basicsize@ */
1339 0, /* @tp_itemsize@ */
1341 0, /* @tp_dealloc@ */
1343 0, /* @tp_getattr@ */
1344 0, /* @tp_setattr@ */
1345 0, /* @tp_compare@ */
1347 0, /* @tp_as_number@ */
1348 0, /* @tp_as_sequence@ */
1349 0, /* @tp_as_mapping@ */
1353 0, /* @tp_getattro@ */
1354 0, /* @tp_setattro@ */
1355 0, /* @tp_as_buffer@ */
1356 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1357 Py_TPFLAGS_BASETYPE
,
1360 "Pseudorandom permutation metaclass.",
1362 0, /* @tp_traverse@ */
1364 0, /* @tp_richcompare@ */
1365 0, /* @tp_weaklistoffset@ */
1367 0, /* @tp_iternext@ */
1368 0, /* @tp_methods@ */
1369 0, /* @tp_members@ */
1370 gcprp_pygetset
, /* @tp_getset@ */
1373 0, /* @tp_descr_get@ */
1374 0, /* @tp_descr_set@ */
1375 0, /* @tp_dictoffset@ */
1377 PyType_GenericAlloc
, /* @tp_alloc@ */
1378 abstract_pynew
, /* @tp_new@ */
1383 static PyTypeObject gprp_pytype_skel
= {
1384 PyObject_HEAD_INIT(0) 0, /* Header */
1385 "GPRP", /* @tp_name@ */
1386 sizeof(gprp_pyobj
), /* @tp_basicsize@ */
1387 0, /* @tp_itemsize@ */
1389 gprp_pydealloc
, /* @tp_dealloc@ */
1391 0, /* @tp_getattr@ */
1392 0, /* @tp_setattr@ */
1393 0, /* @tp_compare@ */
1395 0, /* @tp_as_number@ */
1396 0, /* @tp_as_sequence@ */
1397 0, /* @tp_as_mapping@ */
1401 0, /* @tp_getattro@ */
1402 0, /* @tp_setattro@ */
1403 0, /* @tp_as_buffer@ */
1404 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1405 Py_TPFLAGS_BASETYPE
,
1408 "Pseudorandom permutation, abstract base class.",
1410 0, /* @tp_traverse@ */
1412 0, /* @tp_richcompare@ */
1413 0, /* @tp_weaklistoffset@ */
1415 0, /* @tp_iternext@ */
1416 gprp_pymethods
, /* @tp_methods@ */
1417 0, /* @tp_members@ */
1418 0, /* @tp_getset@ */
1421 0, /* @tp_descr_get@ */
1422 0, /* @tp_descr_set@ */
1423 0, /* @tp_dictoffset@ */
1425 PyType_GenericAlloc
, /* @tp_alloc@ */
1426 abstract_pynew
, /* @tp_new@ */
1431 /*----- Main code ---------------------------------------------------------*/
1433 static PyMethodDef methods
[] = {
1434 #define METHNAME(func) meth_##func
1435 METH (_KeySZ_fromdl
, "\
1436 fromdl(N) -> M: convert integer discrete log field size to work factor")
1437 METH (_KeySZ_fromschnorr
, "\
1438 fromschnorr(N) -> M: convert Schnorr group order to work factor")
1439 METH (_KeySZ_fromif
, "\
1440 fromif(N) -> M: convert integer factorization problem size to work factor")
1441 METH (_KeySZ_fromec
, "\
1442 fromec(N) -> M: convert elliptic curve group order to work factor")
1443 METH (_KeySZ_todl
, "\
1444 todl(N) -> M: convert work factor to integer discrete log field size")
1445 METH (_KeySZ_toschnorr
, "\
1446 toschnorr(N) -> M: convert work factor to Schnorr group order")
1447 METH (_KeySZ_toif
, "\
1448 toif(N) -> M: convert work factor to integer factorization problem size")
1449 METH (_KeySZ_toec
, "\
1450 toec(N) -> M: convert work factor to elliptic curve group order")
1455 void algorithms_pyinit(void)
1457 INITTYPE(keysz
, root
);
1458 INITTYPE(keyszany
, keysz
);
1459 INITTYPE(keyszrange
, keysz
);
1460 INITTYPE(keyszset
, keysz
);
1461 INITTYPE(gccipher
, type
);
1462 INITTYPE(gcipher
, root
);
1463 INITTYPE(gchash
, type
);
1464 INITTYPE(ghash
, root
);
1465 INITTYPE(gcmac
, type
);
1466 INITTYPE(gmac
, type
);
1467 INITTYPE(gmhash
, ghash
);
1468 INITTYPE(gcprp
, type
);
1469 INITTYPE(gprp
, root
);
1470 addmethods(methods
);
1473 GEN(gcciphers
, cipher
)
1476 #define gcprp prpinfo
1479 void algorithms_pyinsert(PyObject
*mod
)
1482 INSERT("KeySZ", keysz_pytype
);
1483 INSERT("KeySZAny", keyszany_pytype
);
1484 INSERT("KeySZRange", keyszrange_pytype
);
1485 INSERT("KeySZSet", keyszset_pytype
);
1486 INSERT("GCCipher", gccipher_pytype
);
1487 INSERT("GCipher", gcipher_pytype
);
1488 INSERT("gcciphers", gcciphers());
1489 INSERT("GCHash", gchash_pytype
);
1490 INSERT("GHash", ghash_pytype
);
1491 INSERT("gchashes", d
= gchashes());
1492 sha_pyobj
= PyDict_GetItemString(d
, "sha"); Py_INCREF(sha_pyobj
);
1493 has160_pyobj
= PyDict_GetItemString(d
, "has160"); Py_INCREF(has160_pyobj
);
1494 INSERT("GCMAC", gcmac_pytype
);
1495 INSERT("GMAC", gmac_pytype
);
1496 INSERT("GMACHash", gmhash_pytype
);
1497 INSERT("gcmacs", gcmacs());
1498 INSERT("GCPRP", gcprp_pytype
);
1499 INSERT("GPRP", gprp_pytype
);
1500 INSERT("gcprps", gcprps());
1503 /*----- That's all, folks -------------------------------------------------*/