5 * Symmetric cryptography
7 * (c) 2004 Straylight/Edgeware
10 /*----- Licensing notice --------------------------------------------------*
12 * This file is part of the Python interface to Catacomb.
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.
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.
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.
29 /*----- Header files ------------------------------------------------------*/
31 #include "catacomb-python.h"
32 #include "algorithms.h"
34 /*----- Key sizes ---------------------------------------------------------*/
36 PyTypeObject
*keysz_pytype
;
37 PyTypeObject
*keyszany_pytype
, *keyszrange_pytype
, *keyszset_pytype
;
38 PyObject
*sha_pyobj
, *has160_pyobj
;
40 PyObject
*keysz_pywrap(const octet
*k
)
44 keysz_pyobj
*o
= PyObject_New(keysz_pyobj
, keyszany_pytype
);
46 return ((PyObject
*)o
);
50 PyObject_New(keyszrange_pyobj
, keyszrange_pytype
);
55 if (!o
->mod
) o
->mod
= 1;
56 return ((PyObject
*)o
);
60 PyObject_New(keyszset_pyobj
, keyszset_pytype
);
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
);
74 static PyObject
*keyszany_pynew(PyTypeObject
*ty
,
75 PyObject
*arg
, PyObject
*kw
)
77 char *kwlist
[] = { "default", 0 };
81 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "i:new", kwlist
, &dfl
))
83 if (dfl
< 0) VALERR("key size cannot be negative");
84 o
= (keysz_pyobj
*)ty
->tp_alloc(ty
, 0);
86 return ((PyObject
*)o
);
91 static PyObject
*keyszrange_pynew(PyTypeObject
*ty
,
92 PyObject
*arg
, PyObject
*kw
)
94 char *kwlist
[] = { "default", "min", "max", "mod", 0 };
95 int dfl
, min
= 0, max
= 0, mod
= 1;
98 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "i|iii:new", kwlist
,
99 &dfl
, &min
, &max
, &mod
))
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);
112 return ((PyObject
*)o
);
117 static PyObject
*keyszset_pynew(PyTypeObject
*ty
,
118 PyObject
*arg
, PyObject
*kw
)
120 char *kwlist
[] = { "default", "set", 0 };
123 PyObject
*x
= 0, *l
= 0;
124 keyszset_pyobj
*o
= 0;
126 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "i|O:new", kwlist
,
129 if (!set
) set
= PyTuple_New(0);
131 if (!PySequence_Check(set
)) TYERR("want a sequence");
132 n
= PySequence_Size(set
);
134 if (PyErr_Occurred()) goto end
;
135 if (dfl
< 0) VALERR("key size cannot be negative");
136 x
= PyInt_FromLong(dfl
);
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");
151 if ((set
= PySequence_Tuple(l
)) == 0) goto end
;
152 o
= (keyszset_pyobj
*)ty
->tp_alloc(ty
, 0);
160 return ((PyObject
*)o
);
163 static PyObject
*kaget_min(PyObject
*me
, void *hunoz
)
164 { return (PyInt_FromLong(0)); }
165 #define kaget_max kaget_min
167 static PyObject
*ksget_min(PyObject
*me
, void *hunoz
)
169 PyObject
*set
= ((keyszset_pyobj
*)me
)->set
;
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
;
176 return (PyInt_FromLong(x
));
179 static PyObject
*ksget_max(PyObject
*me
, void *hunoz
)
181 PyObject
*set
= ((keyszset_pyobj
*)me
)->set
;
183 n
= PyTuple_Size(set
);
184 for (i
= 0; i
< n
; i
++) {
185 y
= PyInt_AsLong(PyTuple_GetItem(set
, i
));
188 return (PyInt_FromLong(x
));
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")
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")
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")
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")
226 static PyMemberDef keyszset_pymembers
[] = {
227 #define MEMBERSTRUCT keyszset_pyobj
228 MEMBER(set
, T_OBJECT
, READONLY
, "KSZ.set -> allowed key sizes")
233 static PyTypeObject keysz_pytype_skel
= {
234 PyObject_HEAD_INIT(0) 0, /* Header */
235 "catacomb.KeySZ", /* @tp_name@ */
236 sizeof(keysz_pyobj
), /* @tp_basicsize@ */
237 0, /* @tp_itemsize@ */
239 0, /* @tp_dealloc@ */
241 0, /* @tp_getattr@ */
242 0, /* @tp_setattr@ */
243 0, /* @tp_compare@ */
245 0, /* @tp_as_number@ */
246 0, /* @tp_as_sequence@ */
247 0, /* @tp_as_mapping@ */
251 0, /* @tp_getattro@ */
252 0, /* @tp_setattro@ */
253 0, /* @tp_as_buffer@ */
254 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
258 "Key size constraints.",
260 0, /* @tp_traverse@ */
262 0, /* @tp_richcompare@ */
263 0, /* @tp_weaklistoffset@ */
265 0, /* @tp_iternext@ */
266 0, /* @tp_methods@ */
267 keysz_pymembers
, /* @tp_members@ */
271 0, /* @tp_descr_get@ */
272 0, /* @tp_descr_set@ */
273 0, /* @tp_dictoffset@ */
275 PyType_GenericAlloc
, /* @tp_alloc@ */
276 abstract_pynew
, /* @tp_new@ */
281 static PyTypeObject keyszany_pytype_skel
= {
282 PyObject_HEAD_INIT(0) 0, /* Header */
283 "catacomb.KeySZAny", /* @tp_name@ */
284 sizeof(keysz_pyobj
), /* @tp_basicsize@ */
285 0, /* @tp_itemsize@ */
287 0, /* @tp_dealloc@ */
289 0, /* @tp_getattr@ */
290 0, /* @tp_setattr@ */
291 0, /* @tp_compare@ */
293 0, /* @tp_as_number@ */
294 0, /* @tp_as_sequence@ */
295 0, /* @tp_as_mapping@ */
299 0, /* @tp_getattro@ */
300 0, /* @tp_setattro@ */
301 0, /* @tp_as_buffer@ */
302 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
306 "Key size constraints. This object imposes no constraints on size.",
308 0, /* @tp_traverse@ */
310 0, /* @tp_richcompare@ */
311 0, /* @tp_weaklistoffset@ */
313 0, /* @tp_iternext@ */
314 0, /* @tp_methods@ */
315 0, /* @tp_members@ */
316 keyszany_pygetset
, /* @tp_getset@ */
319 0, /* @tp_descr_get@ */
320 0, /* @tp_descr_set@ */
321 0, /* @tp_dictoffset@ */
323 PyType_GenericAlloc
, /* @tp_alloc@ */
324 keyszany_pynew
, /* @tp_new@ */
329 static PyTypeObject keyszrange_pytype_skel
= {
330 PyObject_HEAD_INIT(0) 0, /* Header */
331 "catacomb.KeySZRange", /* @tp_name@ */
332 sizeof(keyszrange_pyobj
), /* @tp_basicsize@ */
333 0, /* @tp_itemsize@ */
335 0, /* @tp_dealloc@ */
337 0, /* @tp_getattr@ */
338 0, /* @tp_setattr@ */
339 0, /* @tp_compare@ */
341 0, /* @tp_as_number@ */
342 0, /* @tp_as_sequence@ */
343 0, /* @tp_as_mapping@ */
347 0, /* @tp_getattro@ */
348 0, /* @tp_setattro@ */
349 0, /* @tp_as_buffer@ */
350 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
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.",
357 0, /* @tp_traverse@ */
359 0, /* @tp_richcompare@ */
360 0, /* @tp_weaklistoffset@ */
362 0, /* @tp_iternext@ */
363 0, /* @tp_methods@ */
364 keyszrange_pymembers
, /* @tp_members@ */
368 0, /* @tp_descr_get@ */
369 0, /* @tp_descr_set@ */
370 0, /* @tp_dictoffset@ */
372 PyType_GenericAlloc
, /* @tp_alloc@ */
373 keyszrange_pynew
, /* @tp_new@ */
378 static PyTypeObject keyszset_pytype_skel
= {
379 PyObject_HEAD_INIT(0) 0, /* Header */
380 "catacomb.KeySZSet", /* @tp_name@ */
381 sizeof(keyszset_pyobj
), /* @tp_basicsize@ */
382 0, /* @tp_itemsize@ */
384 0, /* @tp_dealloc@ */
386 0, /* @tp_getattr@ */
387 0, /* @tp_setattr@ */
388 0, /* @tp_compare@ */
390 0, /* @tp_as_number@ */
391 0, /* @tp_as_sequence@ */
392 0, /* @tp_as_mapping@ */
396 0, /* @tp_getattro@ */
397 0, /* @tp_setattro@ */
398 0, /* @tp_as_buffer@ */
399 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
403 "Key size constraints. This object requires the key to be one of a\n\
406 0, /* @tp_traverse@ */
408 0, /* @tp_richcompare@ */
409 0, /* @tp_weaklistoffset@ */
411 0, /* @tp_iternext@ */
412 0, /* @tp_methods@ */
413 keyszset_pymembers
, /* @tp_members@ */
414 keyszset_pygetset
, /* @tp_getset@ */
417 0, /* @tp_descr_get@ */
418 0, /* @tp_descr_set@ */
419 0, /* @tp_dictoffset@ */
421 PyType_GenericAlloc
, /* @tp_alloc@ */
422 keyszset_pynew
, /* @tp_new@ */
427 /*----- Symmetric encryption ----------------------------------------------*/
429 PyTypeObject
*gccipher_pytype
, *gcipher_pytype
;
431 CONVFUNC(gccipher
, gccipher
*, GCCIPHER_CC
)
432 CONVFUNC(gcipher
, gcipher
*, GCIPHER_C
)
434 PyObject
*gcipher_pywrap(PyObject
*cobj
, gcipher
*c
, unsigned f
)
437 if (!cobj
) cobj
= gccipher_pywrap((/*unconst*/ gccipher
*)GC_CLASS(c
));
438 else Py_INCREF(cobj
);
439 g
= PyObject_NEW(gcipher_pyobj
, (PyTypeObject
*)cobj
);
442 return ((PyObject
*)g
);
445 static PyObject
*gcipher_pynew(PyTypeObject
*ty
, PyObject
*arg
, PyObject
*kw
)
447 char *kwlist
[] = { "k", 0 };
451 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "s#:new", kwlist
, &k
, &sz
))
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
),
461 PyObject
*gccipher_pywrap(gccipher
*cc
)
463 gccipher_pyobj
*g
= newtype(gccipher_pytype
, 0, cc
->name
);
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
);
478 static void gcipher_pydealloc(PyObject
*me
)
480 if (GCIPHER_F(me
) & f_freeme
)
481 GC_DESTROY(GCIPHER_C(me
));
482 Py_DECREF(me
->ob_type
);
486 static PyObject
*gccget_name(PyObject
*me
, void *hunoz
)
487 { return (PyString_FromString(GCCIPHER_CC(me
)->name
)); }
489 static PyObject
*gccget_keysz(PyObject
*me
, void *hunoz
)
490 { return (keysz_pywrap(GCCIPHER_CC(me
)->keysz
)); }
492 static PyObject
*gccget_blksz(PyObject
*me
, void *hunoz
)
493 { return (PyInt_FromLong(GCCIPHER_CC(me
)->blksz
)); }
495 static PyObject
*gcmeth_encrypt(PyObject
*me
, PyObject
*arg
)
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
);
507 static PyObject
*gcmeth_enczero(PyObject
*me
, PyObject
*arg
)
513 if (!PyArg_ParseTuple(arg
, "i:enczero", &sz
)) return (0);
514 rc
= bytestring_pywrap(0, sz
);
515 p
= PyString_AS_STRING(rc
);
517 GC_ENCRYPT(GCIPHER_C(me
), p
, p
, sz
);
521 static PyObject
*gcmeth_decrypt(PyObject
*me
, PyObject
*arg
)
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
);
533 static PyObject
*gcmeth_deczero(PyObject
*me
, PyObject
*arg
)
539 if (!PyArg_ParseTuple(arg
, "i:deczero", &sz
)) return (0);
540 rc
= bytestring_pywrap(0, sz
);
541 p
= PyString_AS_STRING(rc
);
543 GC_DECRYPT(GCIPHER_C(me
), p
, p
, sz
);
547 static PyObject
*gcmeth_setiv(PyObject
*me
, PyObject
*arg
)
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
);
561 static PyObject
*gcmeth_bdry(PyObject
*me
, PyObject
*arg
)
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
));
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")
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()")
592 static PyTypeObject gccipher_pytype_skel
= {
593 PyObject_HEAD_INIT(0) 0, /* Header */
594 "catacomb.GCCipher", /* @tp_name@ */
595 sizeof(gccipher_pyobj
), /* @tp_basicsize@ */
596 0, /* @tp_itemsize@ */
598 0, /* @tp_dealloc@ */
600 0, /* @tp_getattr@ */
601 0, /* @tp_setattr@ */
602 0, /* @tp_compare@ */
604 0, /* @tp_as_number@ */
605 0, /* @tp_as_sequence@ */
606 0, /* @tp_as_mapping@ */
610 0, /* @tp_getattro@ */
611 0, /* @tp_setattro@ */
612 0, /* @tp_as_buffer@ */
613 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
617 "Symmetric cipher metaclass.",
619 0, /* @tp_traverse@ */
621 0, /* @tp_richcompare@ */
622 0, /* @tp_weaklistoffset@ */
624 0, /* @tp_iternext@ */
625 0, /* @tp_methods@ */
626 0, /* @tp_members@ */
627 gccipher_pygetset
, /* @tp_getset@ */
630 0, /* @tp_descr_get@ */
631 0, /* @tp_descr_set@ */
632 0, /* @tp_dictoffset@ */
634 PyType_GenericAlloc
, /* @tp_alloc@ */
635 abstract_pynew
, /* @tp_new@ */
640 static PyTypeObject gcipher_pytype_skel
= {
641 PyObject_HEAD_INIT(0) 0, /* Header */
642 "catacomb.GCipher", /* @tp_name@ */
643 sizeof(gcipher_pyobj
), /* @tp_basicsize@ */
644 0, /* @tp_itemsize@ */
646 gcipher_pydealloc
, /* @tp_dealloc@ */
648 0, /* @tp_getattr@ */
649 0, /* @tp_setattr@ */
650 0, /* @tp_compare@ */
652 0, /* @tp_as_number@ */
653 0, /* @tp_as_sequence@ */
654 0, /* @tp_as_mapping@ */
658 0, /* @tp_getattro@ */
659 0, /* @tp_setattro@ */
660 0, /* @tp_as_buffer@ */
661 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
665 "Symmetric cipher, abstract base class.",
667 0, /* @tp_traverse@ */
669 0, /* @tp_richcompare@ */
670 0, /* @tp_weaklistoffset@ */
672 0, /* @tp_iternext@ */
673 gcipher_pymethods
, /* @tp_methods@ */
674 0, /* @tp_members@ */
678 0, /* @tp_descr_get@ */
679 0, /* @tp_descr_set@ */
680 0, /* @tp_dictoffset@ */
682 PyType_GenericAlloc
, /* @tp_alloc@ */
683 abstract_pynew
, /* @tp_new@ */
688 /*----- Hash functions ----------------------------------------------------*/
690 PyTypeObject
*gchash_pytype
, *ghash_pytype
;
692 CONVFUNC(gchash
, gchash
*, GCHASH_CH
)
693 CONVFUNC(ghash
, ghash
*, GHASH_H
)
695 static PyObject
*ghash_pynew(PyTypeObject
*ty
, PyObject
*arg
, PyObject
*kw
)
697 char *kwlist
[] = { 0 };
698 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, ":new", kwlist
))
700 return (ghash_pywrap((PyObject
*)ty
, GH_INIT(GCHASH_CH(ty
)), f_freeme
));
705 PyObject
*gchash_pywrap(gchash
*ch
)
707 gchash_pyobj
*g
= newtype(gchash_pytype
, 0, ch
->name
);
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
);
722 PyObject
*ghash_pywrap(PyObject
*cobj
, ghash
*h
, unsigned f
)
725 if (!cobj
) cobj
= gchash_pywrap((/*unconst*/ gchash
*)GH_CLASS(h
));
726 else Py_INCREF(cobj
);
727 g
= PyObject_NEW(ghash_pyobj
, (PyTypeObject
*)cobj
);
730 return ((PyObject
*)g
);
733 static void ghash_pydealloc(PyObject
*me
)
735 if (GHASH_F(me
) & f_freeme
)
736 GH_DESTROY(GHASH_H(me
));
737 Py_DECREF(me
->ob_type
);
741 static PyObject
*gchget_name(PyObject
*me
, void *hunoz
)
742 { return (PyString_FromString(GCHASH_CH(me
)->name
)); }
744 static PyObject
*gchget_hashsz(PyObject
*me
, void *hunoz
)
745 { return (PyInt_FromLong(GCHASH_CH(me
)->hashsz
)); }
747 static PyObject
*gchget_bufsz(PyObject
*me
, void *hunoz
)
748 { return (PyInt_FromLong(GCHASH_CH(me
)->bufsz
)); }
750 static PyObject
*ghmeth_hash(PyObject
*me
, PyObject
*arg
)
754 if (!PyArg_ParseTuple(arg
, "s#:hash", &p
, &sz
)) return (0);
755 GH_HASH(GHASH_H(me
), p
, sz
);
759 static PyObject
*ghmeth_done(PyObject
*me
, PyObject
*arg
)
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
));
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")
780 #define GHMETH_HASHU_(n, W, w) \
781 static PyObject *ghmeth_hashu##w(PyObject *me, PyObject *arg) \
784 if (!PyArg_ParseTuple(arg, "O&:hashu" #w, convu##n, &x)) goto end; \
785 GH_HASHU##W(GHASH_H(me), x); \
790 DOUINTCONV(GHMETH_HASHU_
)
792 #define GHMETH_HASHBUF_(n, W, w) \
793 static PyObject *ghmeth_hashbuf##w(PyObject *me, PyObject *arg) \
797 if (!PyArg_ParseTuple(arg, "s#:hashbuf" #w, &p, &sz)) goto end; \
798 if (sz > MASK##n) TYERR("string too long"); \
799 GH_HASHBUF##W(GHASH_H(me), p, sz); \
804 DOUINTCONV(GHMETH_HASHBUF_
)
806 static PyObject
*ghmeth_hashstrz(PyObject
*me
, PyObject
*arg
)
809 if (!PyArg_ParseTuple(arg
, "s:hashstrz", &p
)) return (0);
810 GH_HASHSTRZ(GHASH_H(me
), p
);
814 static PyMethodDef ghash_pymethods
[] = {
815 #define METHNAME(name) ghmeth_##name
816 METH (hash
, "H.hash(M)")
817 #define METHU_(n, W, w) METH(hashu##w, "H.hashu" #w "(WORD)")
819 #define METHBUF_(n, W, w) METH(hashbuf##w, "H.hashbuf" #w "(BYTES)")
821 METH (hashstrz
, "H.hashstrz(STRING)")
822 METH (done
, "H.done() -> HASH")
827 static PyTypeObject gchash_pytype_skel
= {
828 PyObject_HEAD_INIT(0) 0, /* Header */
829 "catacomb.GCHash", /* @tp_name@ */
830 sizeof(gchash_pyobj
), /* @tp_basicsize@ */
831 0, /* @tp_itemsize@ */
833 0, /* @tp_dealloc@ */
835 0, /* @tp_getattr@ */
836 0, /* @tp_setattr@ */
837 0, /* @tp_compare@ */
839 0, /* @tp_as_number@ */
840 0, /* @tp_as_sequence@ */
841 0, /* @tp_as_mapping@ */
845 0, /* @tp_getattro@ */
846 0, /* @tp_setattro@ */
847 0, /* @tp_as_buffer@ */
848 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
852 "Hash function metaclass.",
854 0, /* @tp_traverse@ */
856 0, /* @tp_richcompare@ */
857 0, /* @tp_weaklistoffset@ */
859 0, /* @tp_iternext@ */
860 0, /* @tp_methods@ */
861 0, /* @tp_members@ */
862 gchash_pygetset
, /* @tp_getset@ */
865 0, /* @tp_descr_get@ */
866 0, /* @tp_descr_set@ */
867 0, /* @tp_dictoffset@ */
869 PyType_GenericAlloc
, /* @tp_alloc@ */
870 abstract_pynew
, /* @tp_new@ */
875 static PyTypeObject ghash_pytype_skel
= {
876 PyObject_HEAD_INIT(0) 0, /* Header */
877 "catacomb.GHash", /* @tp_name@ */
878 sizeof(ghash_pyobj
), /* @tp_basicsize@ */
879 0, /* @tp_itemsize@ */
881 ghash_pydealloc
, /* @tp_dealloc@ */
883 0, /* @tp_getattr@ */
884 0, /* @tp_setattr@ */
885 0, /* @tp_compare@ */
887 0, /* @tp_as_number@ */
888 0, /* @tp_as_sequence@ */
889 0, /* @tp_as_mapping@ */
893 0, /* @tp_getattro@ */
894 0, /* @tp_setattro@ */
895 0, /* @tp_as_buffer@ */
896 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
900 "Hash function, abstract base class.",
902 0, /* @tp_traverse@ */
904 0, /* @tp_richcompare@ */
905 0, /* @tp_weaklistoffset@ */
907 0, /* @tp_iternext@ */
908 ghash_pymethods
, /* @tp_methods@ */
909 0, /* @tp_members@ */
913 0, /* @tp_descr_get@ */
914 0, /* @tp_descr_set@ */
915 0, /* @tp_dictoffset@ */
917 PyType_GenericAlloc
, /* @tp_alloc@ */
918 abstract_pynew
, /* @tp_new@ */
923 /*----- Message authentication --------------------------------------------*/
925 PyTypeObject
*gcmac_pytype
, *gmac_pytype
, *gmhash_pytype
;
927 CONVFUNC(gcmac
, gcmac
*, GCMAC_CM
)
928 CONVFUNC(gmac
, gmac
*, GMAC_M
)
929 CONVFUNC(gmhash
, ghash
*, GHASH_H
)
931 static PyObject
*gmac_pynew(PyTypeObject
*ty
, PyObject
*arg
, PyObject
*kw
)
933 char *kwlist
[] = { "k", 0 };
937 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, "s#:new", kwlist
, &k
, &sz
))
939 if (keysz(sz
, GCMAC_CM(ty
)->keysz
) != sz
) VALERR("bad key length");
940 return (gmac_pywrap((PyObject
*)ty
,
941 GM_KEY(GCMAC_CM(ty
), k
, sz
),
947 static PyObject
*gmhash_pynew(PyTypeObject
*ty
, PyObject
*arg
, PyObject
*kw
)
949 char *kwlist
[] = { 0 };
952 if (!PyArg_ParseTupleAndKeywords(arg
, kw
, ":new", kwlist
)) return (0);
953 g
= PyObject_NEW(ghash_pyobj
, ty
);
954 g
->h
= GM_INIT(GMAC_M(ty
));
957 return ((PyObject
*)g
);
960 PyObject
*gcmac_pywrap(gcmac
*cm
)
962 gcmac_pyobj
*g
= newtype(gcmac_pytype
, 0, cm
->name
);
964 g
->ty
.type
.tp_basicsize
= sizeof(gmac_pyobj
);
965 g
->ty
.type
.tp_base
= gmac_pytype
;
966 Py_INCREF(gmac_pytype
);
967 g
->ty
.type
.tp_flags
= (Py_TPFLAGS_DEFAULT
|
968 Py_TPFLAGS_BASETYPE
|
969 Py_TPFLAGS_HEAPTYPE
);
970 g
->ty
.type
.tp_alloc
= PyType_GenericAlloc
;
971 g
->ty
.type
.tp_free
= 0;
972 g
->ty
.type
.tp_new
= gmac_pynew
;
973 PyType_Ready(&g
->ty
.type
);
974 return ((PyObject
*)g
);
977 PyObject
*gmac_pywrap(PyObject
*cobj
, gmac
*m
, unsigned f
)
980 if (!cobj
) cobj
= gcmac_pywrap((/*unconst*/ gcmac
*)GM_CLASS(m
));
981 else Py_INCREF(cobj
);
982 g
= newtype((PyTypeObject
*)cobj
, 0, 0);
983 g
->ty
.name
= PyString_FromFormat("%s(keyed)", m
->ops
->c
->name
);
984 g
->ty
.type
.tp_name
= PyString_AS_STRING(g
->ty
.name
);
985 g
->ty
.type
.tp_base
= gmhash_pytype
;
986 Py_INCREF(gmac_pytype
);
987 g
->ty
.type
.tp_flags
= (Py_TPFLAGS_DEFAULT
|
988 Py_TPFLAGS_BASETYPE
|
989 Py_TPFLAGS_HEAPTYPE
);
990 g
->ty
.type
.tp_alloc
= PyType_GenericAlloc
;
991 g
->ty
.type
.tp_free
= 0;
992 g
->ty
.type
.tp_new
= gmhash_pynew
;
993 PyType_Ready(&g
->ty
.type
);
996 return ((PyObject
*)g
);
999 static void gmac_pydealloc(PyObject
*me
)
1001 if (GMAC_F(me
) & f_freeme
)
1002 GM_DESTROY(GMAC_M(me
));
1003 Py_DECREF(me
->ob_type
);
1004 PyType_Type
.tp_dealloc(me
);
1007 static PyObject
*gcmget_name(PyObject
*me
, void *hunoz
)
1008 { return (PyString_FromString(GCMAC_CM(me
)->name
)); }
1010 static PyObject
*gcmget_keysz(PyObject
*me
, void *hunoz
)
1011 { return (keysz_pywrap(GCMAC_CM(me
)->keysz
)); }
1013 static PyObject
*gcmget_tagsz(PyObject
*me
, void *hunoz
)
1014 { return (PyInt_FromLong(GCMAC_CM(me
)->hashsz
)); }
1016 static PyGetSetDef gcmac_pygetset
[] = {
1017 #define GETSETNAME(op, name) gcm##op##_##name
1018 GET (keysz
, "CM.keysz -> acceptable key sizes")
1019 GET (tagsz
, "CM.tagsz -> MAC output size")
1020 GET (name
, "CM.name -> name of this kind of MAC")
1025 static PyTypeObject gcmac_pytype_skel
= {
1026 PyObject_HEAD_INIT(0) 0, /* Header */
1027 "catacomb.GCMAC", /* @tp_name@ */
1028 sizeof(gchash_pyobj
), /* @tp_basicsize@ */
1029 0, /* @tp_itemsize@ */
1031 0, /* @tp_dealloc@ */
1033 0, /* @tp_getattr@ */
1034 0, /* @tp_setattr@ */
1035 0, /* @tp_compare@ */
1037 0, /* @tp_as_number@ */
1038 0, /* @tp_as_sequence@ */
1039 0, /* @tp_as_mapping@ */
1043 0, /* @tp_getattro@ */
1044 0, /* @tp_setattro@ */
1045 0, /* @tp_as_buffer@ */
1046 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1047 Py_TPFLAGS_BASETYPE
,
1050 "Message authentication code metametaclass.",
1052 0, /* @tp_traverse@ */
1054 0, /* @tp_richcompare@ */
1055 0, /* @tp_weaklistoffset@ */
1057 0, /* @tp_iternext@ */
1058 0, /* @tp_methods@ */
1059 0, /* @tp_members@ */
1060 gcmac_pygetset
, /* @tp_getset@ */
1063 0, /* @tp_descr_get@ */
1064 0, /* @tp_descr_set@ */
1065 0, /* @tp_dictoffset@ */
1067 PyType_GenericAlloc
, /* @tp_alloc@ */
1068 abstract_pynew
, /* @tp_new@ */
1073 static PyTypeObject gmac_pytype_skel
= {
1074 PyObject_HEAD_INIT(0) 0, /* Header */
1075 "catacomb.GMAC", /* @tp_name@ */
1076 sizeof(gmac_pyobj
), /* @tp_basicsize@ */
1077 0, /* @tp_itemsize@ */
1079 gmac_pydealloc
, /* @tp_dealloc@ */
1081 0, /* @tp_getattr@ */
1082 0, /* @tp_setattr@ */
1083 0, /* @tp_compare@ */
1085 0, /* @tp_as_number@ */
1086 0, /* @tp_as_sequence@ */
1087 0, /* @tp_as_mapping@ */
1091 0, /* @tp_getattro@ */
1092 0, /* @tp_setattro@ */
1093 0, /* @tp_as_buffer@ */
1094 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1095 Py_TPFLAGS_BASETYPE
,
1098 "Message authentication code metaclass, abstract base class.",
1100 0, /* @tp_traverse@ */
1102 0, /* @tp_richcompare@ */
1103 0, /* @tp_weaklistoffset@ */
1105 0, /* @tp_iternext@ */
1106 0, /* @tp_methods@ */
1107 0, /* @tp_members@ */
1108 0, /* @tp_getset@ */
1111 0, /* @tp_descr_get@ */
1112 0, /* @tp_descr_set@ */
1113 0, /* @tp_dictoffset@ */
1115 PyType_GenericAlloc
, /* @tp_alloc@ */
1116 abstract_pynew
, /* @tp_new@ */
1121 static PyTypeObject gmhash_pytype_skel
= {
1122 PyObject_HEAD_INIT(0) 0, /* Header */
1123 "catacomb.GMACHash", /* @tp_name@ */
1124 sizeof(ghash_pyobj
), /* @tp_basicsize@ */
1125 0, /* @tp_itemsize@ */
1127 ghash_pydealloc
, /* @tp_dealloc@ */
1129 0, /* @tp_getattr@ */
1130 0, /* @tp_setattr@ */
1131 0, /* @tp_compare@ */
1133 0, /* @tp_as_number@ */
1134 0, /* @tp_as_sequence@ */
1135 0, /* @tp_as_mapping@ */
1139 0, /* @tp_getattro@ */
1140 0, /* @tp_setattro@ */
1141 0, /* @tp_as_buffer@ */
1142 Py_TPFLAGS_DEFAULT
| /* @tp_flags@ */
1143 Py_TPFLAGS_BASETYPE
,
1146 "Message authentication code, abstract base class.",
1148 0, /* @tp_traverse@ */
1150 0, /* @tp_richcompare@ */
1151 0, /* @tp_weaklistoffset@ */
1153 0, /* @tp_iternext@ */
1154 0, /* @tp_methods@ */
1155 0, /* @tp_members@ */
1156 0, /* @tp_getset@ */
1159 0, /* @tp_descr_get@ */
1160 0, /* @tp_descr_set@ */
1161 0, /* @tp_dictoffset@ */
1163 PyType_GenericAlloc
, /* @tp_alloc@ */
1164 abstract_pynew
, /* @tp_new@ */
1169 /*----- Main code ---------------------------------------------------------*/
1171 void algorithms_pyinit(void)
1173 INITTYPE(keysz
, root
);
1174 INITTYPE(keyszany
, keysz
);
1175 INITTYPE(keyszrange
, keysz
);
1176 INITTYPE(keyszset
, keysz
);
1177 INITTYPE(gccipher
, type
);
1178 INITTYPE(gcipher
, root
);
1179 INITTYPE(gchash
, type
);
1180 INITTYPE(ghash
, root
);
1181 INITTYPE(gcmac
, type
);
1182 INITTYPE(gmac
, type
);
1183 INITTYPE(gmhash
, ghash
);
1186 #define GEN(func, base) \
1187 static PyObject *func(void) \
1189 PyObject *d = PyDict_New(); \
1193 for (i = 0; g##base##tab[i]; i++) { \
1194 o = gc##base##_pywrap((/*unconst*/ gc##base *)g##base##tab[i]); \
1195 PyDict_SetItemString(d, \
1196 (/*unconst*/ char *)g##base##tab[i]->name, \
1202 GEN(gcciphers
, cipher
)
1206 void algorithms_pyinsert(PyObject
*mod
)
1209 INSERT("KeySZ", keysz_pytype
);
1210 INSERT("KeySZAny", keyszany_pytype
);
1211 INSERT("KeySZRange", keyszrange_pytype
);
1212 INSERT("KeySZSet", keyszset_pytype
);
1213 INSERT("GCCipher", gccipher_pytype
);
1214 INSERT("GCipher", gcipher_pytype
);
1215 INSERT("gcciphers", gcciphers());
1216 INSERT("GCHash", gchash_pytype
);
1217 INSERT("GHash", ghash_pytype
);
1218 INSERT("gchashes", d
= gchashes());
1219 sha_pyobj
= PyDict_GetItemString(d
, "sha"); Py_INCREF(sha_pyobj
);
1220 has160_pyobj
= PyDict_GetItemString(d
, "has160"); Py_INCREF(has160_pyobj
);
1221 INSERT("GCMAC", gcmac_pytype
);
1222 INSERT("GMAC", gmac_pytype
);
1223 INSERT("GMACHash", gmhash_pytype
);
1224 INSERT("gcmacs", gcmacs());
1227 /*----- That's all, folks -------------------------------------------------*/