X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb-python/blobdiff_plain/be17c8c27ee7ae2e14fe34bb517484a11b1cf300..f05b013bba23c63a664053c91e5107a25b67b933:/algorithms.c diff --git a/algorithms.c b/algorithms.c index babee57..be07fb7 100644 --- a/algorithms.c +++ b/algorithms.c @@ -86,12 +86,13 @@ PyObject *keysz_pywrap(const octet *k) case KSZ_SET: { keyszset_pyobj *o = PyObject_New(keyszset_pyobj, keyszset_pytype); + PyObject *l; int i, n; o->dfl = ARG(0); for (i = 0; ARG(i); i++) ; - n = i; o->set = PyTuple_New(n); - for (i = 0; i < n; i++) - PyTuple_SET_ITEM(o->set, i, PyInt_FromLong(ARG(i))); + n = i; l = PyList_New(n); + for (i = 0; i < n; i++) PyList_SET_ITEM(l, i, PyInt_FromLong(ARG(i))); + o->set = PyFrozenSet_New(l); Py_DECREF(l); return ((PyObject *)o); } break; default: @@ -121,13 +122,20 @@ static PyObject *keyszrange_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw) { static const char *const kwlist[] = { "default", "min", "max", "mod", 0 }; - int dfl, min = 0, max = 0, mod = 1; + int dfl, min = 0, max, mod = 1; + PyObject *maxobj = Py_None; keyszrange_pyobj *o; - if (!PyArg_ParseTupleAndKeywords(arg, kw, "i|iii:new", KWLIST, - &dfl, &min, &max, &mod)) + if (!PyArg_ParseTupleAndKeywords(arg, kw, "i|iOi:new", KWLIST, + &dfl, &min, &maxobj, &mod)) goto end; - if (dfl < 0 || min < 0) VALERR("key size cannot be negative"); + if (maxobj == Py_None) + max = 0; + else { + max = PyInt_AsLong(maxobj); + if (max == -1 && PyErr_Occurred()) goto end; + } + if (dfl < 0 || min < 0 || max < 0) VALERR("key size cannot be negative"); if (min > dfl || (max && dfl > max)) VALERR("bad key size bounds"); if (mod <= 0 || dfl%mod || min%mod || max%mod) VALERR("bad key size modulus"); @@ -145,41 +153,30 @@ static PyObject *keyszset_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw) { static const char *const kwlist[] = { "default", "set", 0 }; - int dfl, i, n, xx; + int dfl, xx; PyObject *set = 0; - PyObject *x = 0, *l = 0; + PyObject *x = 0, *l = 0, *i = 0; keyszset_pyobj *o = 0; if (!PyArg_ParseTupleAndKeywords(arg, kw, "i|O:new", KWLIST, &dfl, &set)) goto end; - if (!set) set = PyTuple_New(0); - else Py_INCREF(set); - if (!PySequence_Check(set)) TYERR("want a sequence"); - n = PySequence_Size(set); if (n < 0) goto end; + if (set) i = PyObject_GetIter(set); + else { set = PyTuple_New(0); i = PyObject_GetIter(set); Py_DECREF(set); } + if (!i) goto end; l = PyList_New(0); if (!l) goto end; if (dfl < 0) VALERR("key size cannot be negative"); - x = PyInt_FromLong(dfl); - PyList_Append(l, x); - Py_DECREF(x); - x = 0; - for (i = 0; i < n; i++) { - if ((x = PySequence_GetItem(set, i)) == 0) goto end; - xx = PyInt_AsLong(x); - if (PyErr_Occurred()) goto end; - if (xx == dfl) continue; + x = PyInt_FromLong(dfl); PyList_Append(l, x); Py_DECREF(x); x = 0; + for (;;) { + x = PyIter_Next(i); if (!x) break; + xx = PyInt_AsLong(x); if (xx == -1 && PyErr_Occurred()) goto end; if (xx < 0) VALERR("key size cannot be negative"); - PyList_Append(l, x); - Py_DECREF(x); - x = 0; + PyList_Append(l, x); Py_DECREF(x); x = 0; } - Py_DECREF(set); - if ((set = PySequence_Tuple(l)) == 0) goto end; + if ((set = PyFrozenSet_New(l)) == 0) goto end; o = (keyszset_pyobj *)ty->tp_alloc(ty, 0); o->dfl = dfl; o->set = set; - Py_INCREF(set); end: - Py_XDECREF(set); Py_XDECREF(l); Py_XDECREF(x); return ((PyObject *)o); @@ -187,29 +184,43 @@ end: static PyObject *kaget_min(PyObject *me, void *hunoz) { return (PyInt_FromLong(0)); } -#define kaget_max kaget_min +static PyObject *kaget_max(PyObject *me, void *hunoz) + { RETURN_NONE; } + +static PyObject *krget_max(PyObject *me, void *hunoz) +{ + int max = ((keyszrange_pyobj *)me)->max; + if (max) return (PyInt_FromLong(max)); + else RETURN_NONE; +} static PyObject *ksget_min(PyObject *me, void *hunoz) { - PyObject *set = ((keyszset_pyobj *)me)->set; - int i, n, y, x = -1; - n = PyTuple_GET_SIZE(set); - for (i = 0; i < n; i++) { - y = PyInt_AS_LONG(PyTuple_GET_ITEM(set, i)); + PyObject *i = PyObject_GetIter(((keyszset_pyobj *)me)->set); + PyObject *v = 0; + int y, x = -1; + for (;;) { + v = PyIter_Next(i); if (!v) break; + y = PyInt_AsLong(v); assert(y >= 0); if (x == -1 || y < x) x = y; } + Py_DECREF(i); Py_XDECREF(v); + if (PyErr_Occurred()) return (0); return (PyInt_FromLong(x)); } static PyObject *ksget_max(PyObject *me, void *hunoz) { - PyObject *set = ((keyszset_pyobj *)me)->set; - int i, n, y, x = -1; - n = PyTuple_GET_SIZE(set); - for (i = 0; i < n; i++) { - y = PyInt_AS_LONG(PyTuple_GET_ITEM(set, i)); + PyObject *i = PyObject_GetIter(((keyszset_pyobj *)me)->set); + PyObject *v = 0; + int y, x = -1; + for (;;) { + v = PyIter_Next(i); if (!v) break; + y = PyInt_AsLong(v); assert(y >= 0); if (y > x) x = y; } + Py_DECREF(i); Py_XDECREF(v); + if (PyErr_Occurred()) return (0); return (PyInt_FromLong(x)); } @@ -273,13 +284,19 @@ static const PyGetSetDef keyszany_pygetset[] = { static const PyMemberDef keyszrange_pymembers[] = { #define MEMBERSTRUCT keyszrange_pyobj MEMBER(min, T_INT, READONLY, "KSZ.min -> smallest allowed key size") - MEMBER(max, T_INT, READONLY, "KSZ.max -> largest allowed key size") MEMBER(mod, T_INT, READONLY, "KSZ.mod -> key size must be a multiple of this") #undef MEMBERSTRUCT { 0 } }; +static const PyGetSetDef keyszrange_pygetset[] = { +#define GETSETNAME(op, name) kr##op##_##name + GET (max, "KSZ.max -> largest allowed key size") +#undef GETSETNAME + { 0 } +}; + static const PyGetSetDef keyszset_pygetset[] = { #define GETSETNAME(op, name) ks##op##_##name GET (min, "KSZ.min -> smallest allowed key size") @@ -429,7 +446,7 @@ static const PyTypeObject keyszrange_pytype_skel = { 0, /* @tp_iternext@ */ 0, /* @tp_methods@ */ PYMEMBERS(keyszrange), /* @tp_members@ */ - 0, /* @tp_getset@ */ + PYGETSET(keyszrange), /* @tp_getset@ */ 0, /* @tp_base@ */ 0, /* @tp_dict@ */ 0, /* @tp_descr_get@ */ @@ -467,8 +484,8 @@ static const PyTypeObject keyszset_pytype_skel = { Py_TPFLAGS_BASETYPE, /* @tp_doc@ */ - "KeySZSet(DEFAULT, SEQ)\n" - " Key size constraints: size must be DEFAULT or an element of SEQ.", + "KeySZSet(DEFAULT, ITER)\n" + " Key size constraints: size must be DEFAULT or an element of ITER.", 0, /* @tp_traverse@ */ 0, /* @tp_clear@ */ @@ -562,7 +579,7 @@ static void gcipher_pydealloc(PyObject *me) } static PyObject *gccget_name(PyObject *me, void *hunoz) - { return (PyString_FromString(GCCIPHER_CC(me)->name)); } + { return (TEXT_FROMSTR(GCCIPHER_CC(me)->name)); } static PyObject *gccget_keysz(PyObject *me, void *hunoz) { return (keysz_pywrap(GCCIPHER_CC(me)->keysz)); } @@ -577,7 +594,7 @@ static PyObject *gcmeth_encrypt(PyObject *me, PyObject *arg) if (!PyArg_ParseTuple(arg, "O&:encrypt", convbin, &m)) return (0); rc = bytestring_pywrap(0, m.sz); - GC_ENCRYPT(GCIPHER_C(me), m.p, PyString_AS_STRING(rc), m.sz); + GC_ENCRYPT(GCIPHER_C(me), m.p, BIN_PTR(rc), m.sz); return (rc); } @@ -589,7 +606,7 @@ static PyObject *gcmeth_enczero(PyObject *me, PyObject *arg) if (!PyArg_ParseTuple(arg, "i:enczero", &sz)) return (0); rc = bytestring_pywrap(0, sz); - p = PyString_AS_STRING(rc); + p = BIN_PTR(rc); memset(p, 0, sz); GC_ENCRYPT(GCIPHER_C(me), p, p, sz); return (rc); @@ -602,7 +619,7 @@ static PyObject *gcmeth_decrypt(PyObject *me, PyObject *arg) if (!PyArg_ParseTuple(arg, "O&:decrypt", convbin, &c)) return (0); rc = bytestring_pywrap(0, c.sz); - GC_DECRYPT(GCIPHER_C(me), c.p, PyString_AS_STRING(rc), c.sz); + GC_DECRYPT(GCIPHER_C(me), c.p, BIN_PTR(rc), c.sz); return (rc); } @@ -614,7 +631,7 @@ static PyObject *gcmeth_deczero(PyObject *me, PyObject *arg) if (!PyArg_ParseTuple(arg, "i:deczero", &sz)) return (0); rc = bytestring_pywrap(0, sz); - p = PyString_AS_STRING(rc); + p = BIN_PTR(rc); memset(p, 0, sz); GC_DECRYPT(GCIPHER_C(me), p, p, sz); return (rc); @@ -902,8 +919,8 @@ static PyObject *gcaead_pywrap(gcaead *aec) #define MKTYPE(obj, thing, newfn, namefmt) do { \ (obj) = newtype(gcaead_pytype, 0, 0); \ - (obj)->ty.ht_name = PyString_FromFormat(namefmt, aec->name); \ - (obj)->ty.ht_type.tp_name = PyString_AS_STRING((obj)->ty.ht_name); \ + (obj)->ty.ht_name = TEXT_FORMAT(namefmt, aec->name); \ + (obj)->ty.ht_type.tp_name = TEXT_PTR((obj)->ty.ht_name); \ (obj)->ty.ht_type.tp_basicsize = sizeof(gaead##thing##_pyobj); \ (obj)->ty.ht_type.tp_base = gaead##thing##_pytype; \ Py_INCREF(gaead##thing##_pytype); \ @@ -931,7 +948,7 @@ static void gaeadkey_pydealloc(PyObject *me) { GAEAD_DESTROY(GAEADKEY_K(me)); Py_DECREF(Py_TYPE(me)); FREEOBJ(me); } static PyObject *gcaeget_name(PyObject *me, void *hunoz) - { return (PyString_FromString(GCAEAD_AEC(me)->name)); } + { return (TEXT_FROMSTR(GCAEAD_AEC(me)->name)); } static PyObject *gcaeget_keysz(PyObject *me, void *hunoz) { return (keysz_pywrap(GCAEAD_AEC(me)->keysz)); } @@ -1153,7 +1170,6 @@ end: return (rc); } - static PyObject *gaeameth_hash(PyObject *me, PyObject *arg) { struct bin h; @@ -1178,7 +1194,7 @@ DOUINTCONV(GAEAMETH_HASHU_) { \ struct bin in; octet b[SZ_##W]; \ if (!PyArg_ParseTuple(arg, "O&:hashbuf" #w, convbin, &in)) goto end; \ - if (in.sz > MASK##n) TYERR("string too long"); \ + if (in.sz > MASK##n) VALERR("too large"); \ STORE##W(b, in.sz); if (gaeadaad_hash(me, b, sizeof(b))) goto end; \ if (gaeadaad_hash(me, in.p, in.sz)) goto end; \ RETURN_ME; \ @@ -1367,7 +1383,7 @@ static PyObject *gaeemeth_done(PyObject *me, PyObject *arg, PyObject *kw) csz = ge->e->ops->c->bufsz; c = xmalloc(csz); buf_init(&b, c, csz); tag = bytestring_pywrap(0, tsz); err = GAEAD_DONE(ge->e, aad == Py_None ? 0 : GAEADAAD_A(aad), &b, - PyString_AS_STRING(tag), tsz); + BIN_PTR(tag), tsz); assert(!err); (void)err; buf_flip(&b); rc = Py_BuildValue("NN", bytestring_pywrapbuf(&b), tag); end: @@ -1994,7 +2010,7 @@ static void ghash_pydealloc(PyObject *me) } static PyObject *gchget_name(PyObject *me, void *hunoz) - { return (PyString_FromString(GCHASH_CH(me)->name)); } + { return (TEXT_FROMSTR(GCHASH_CH(me)->name)); } static PyObject *gchget_hashsz(PyObject *me, void *hunoz) { return (PyInt_FromLong(GCHASH_CH(me)->hashsz)); } @@ -2028,7 +2044,7 @@ DOUINTCONV(GHMETH_HASHU_) { \ struct bin in; \ if (!PyArg_ParseTuple(arg, "O&:hashbuf" #w, convbin, &in)) goto end; \ - if (in.sz > MASK##n) TYERR("string too long"); \ + if (in.sz > MASK##n) VALERR("too large"); \ GH_HASHBUF##W(GHASH_H(me), in.p, in.sz); \ RETURN_ME; \ end: \ @@ -2050,7 +2066,7 @@ static PyObject *ghmeth_done(PyObject *me) PyObject *rc; g = GH_COPY(GHASH_H(me)); rc = bytestring_pywrap(0, g->ops->c->hashsz); - GH_DONE(g, PyString_AS_STRING(rc)); + GH_DONE(g, BIN_PTR(rc)); GH_DESTROY(g); return (rc); } @@ -2253,8 +2269,8 @@ static PyObject *gmac_pywrap(PyObject *cobj, gmac *m) else Py_INCREF(cobj); g = newtype((PyTypeObject *)cobj, 0, 0); g->ty.ht_type.tp_basicsize = sizeof(ghash_pyobj); - g->ty.ht_name = PyString_FromFormat("%s(keyed)", m->ops->c->name); - g->ty.ht_type.tp_name = PyString_AS_STRING(g->ty.ht_name); + g->ty.ht_name = TEXT_FORMAT("%s(keyed)", m->ops->c->name); + g->ty.ht_type.tp_name = TEXT_PTR(g->ty.ht_name); g->ty.ht_type.tp_base = gmhash_pytype; Py_INCREF(gmac_pytype); g->ty.ht_type.tp_flags = (Py_TPFLAGS_DEFAULT | @@ -2276,7 +2292,7 @@ static void gmac_pydealloc(PyObject *me) } static PyObject *gcmget_name(PyObject *me, void *hunoz) - { return (PyString_FromString(GCMAC_CM(me)->name)); } + { return (TEXT_FROMSTR(GCMAC_CM(me)->name)); } static PyObject *gcmget_keysz(PyObject *me, void *hunoz) { return (keysz_pywrap(GCMAC_CM(me)->keysz)); } @@ -2293,6 +2309,22 @@ static const PyGetSetDef gcmac_pygetset[] = { { 0 } }; +static PyObject *gmget_name(PyObject *me, void *hunoz) + { return (TEXT_FROMSTR(GMAC_M(me)->ops->c->name)); } + +static PyObject *gmget_hashsz(PyObject *me, void *hunoz) + { return (PyInt_FromLong(GMAC_M(me)->ops->c->hashsz)); } +#define gmget_tagsz gmget_hashsz + +static const PyGetSetDef gmac_pygetset[] = { +#define GETSETNAME(op, name) gm##op##_##name + GET (hashsz, "M.hashsz -> MAC output size") + GET (tagsz, "M.tagsz -> MAC output size") + GET (name, "M.name -> name of this kind of MAC") +#undef GETSETNAME + { 0 } +}; + static const PyTypeObject gcmac_pytype_skel = { PyVarObject_HEAD_INIT(0, 0) /* Header */ "GCMAC", /* @tp_name@ */ @@ -2376,7 +2408,7 @@ static const PyTypeObject gmac_pytype_skel = { 0, /* @tp_iternext@ */ 0, /* @tp_methods@ */ 0, /* @tp_members@ */ - 0, /* @tp_getset@ */ + PYGETSET(gmac), /* @tp_getset@ */ 0, /* @tp_base@ */ 0, /* @tp_dict@ */ 0, /* @tp_descr_get@ */ @@ -2490,9 +2522,9 @@ static PyObject *poly1305key_pynew(PyTypeObject *ty, if (keysz(k.sz, poly1305_keysz) != k.sz) VALERR("bad key length"); pk = newtype(ty, 0, 0); - pk->ty.ht_name = PyString_FromString("poly1305(keyed)"); + pk->ty.ht_name = TEXT_FROMSTR("poly1305(keyed)"); pk->ty.ht_type.tp_basicsize = sizeof(poly1305hash_pyobj); - pk->ty.ht_type.tp_name = PyString_AS_STRING(pk->ty.ht_name); + pk->ty.ht_type.tp_name = TEXT_PTR(pk->ty.ht_name); pk->ty.ht_type.tp_base = poly1305hash_pytype; Py_INCREF(poly1305key_pytype); pk->ty.ht_type.tp_flags = (Py_TPFLAGS_DEFAULT | @@ -2511,7 +2543,7 @@ end: } static PyObject *poly1305clsget_name(PyObject *me, void *hunoz) - { return (PyString_FromString("poly1305")); } + { return (TEXT_FROMSTR("poly1305")); } static PyObject *poly1305clsget_keysz(PyObject *me, void *hunoz) { return (keysz_pywrap(poly1305_keysz)); } @@ -2556,7 +2588,7 @@ DOUINTCONV(POLYMETH_HASHU_) struct bin in; \ octet b[SZ_##W]; \ if (!PyArg_ParseTuple(arg, "O&:hashbuf" #w, convbin, &in)) goto end; \ - if (in.sz > MASK##n) TYERR("string too long"); \ + if (in.sz > MASK##n) VALERR("too large"); \ STORE##W(b, in.sz); poly1305_hash(P1305_CTX(me), b, sizeof(b)); \ poly1305_hash(P1305_CTX(me), in.p, in.sz); \ RETURN_ME; \ @@ -2600,7 +2632,7 @@ static PyObject *polymeth_done(PyObject *me) PyObject *rc; if (!(P1305_F(me) & f_mask)) VALERR("no mask"); rc = bytestring_pywrap(0, POLY1305_TAGSZ); - poly1305_done(P1305_CTX(me), PyString_AS_STRING(rc)); + poly1305_done(P1305_CTX(me), BIN_PTR(rc)); return (rc); end: return (0); @@ -2616,6 +2648,20 @@ static const PyGetSetDef poly1305cls_pygetset[] = { { 0 } }; +static PyObject *poly1305get_name(PyObject *me, void *hunoz) + { RETURN_OBJ(((PyHeapTypeObject *)poly1305key_pytype)->ht_name); } + +static PyObject *poly1305get_tagsz(PyObject *me, void *hunoz) + { return (PyInt_FromLong(16)); } + +static const PyGetSetDef poly1305_pygetset[] = { +#define GETSETNAME(op, name) poly1305##op##_##name + GET (tagsz, "PK.tagsz -> MAC output size") + GET (name, "PK.name -> name of this kind of MAC") +#undef GETSETNAME + { 0 } +}; + static const PyMethodDef poly1305hash_pymethods[] = { #define METHNAME(name) polymeth_##name NAMETH(copy, "P.copy() -> PP") @@ -2637,7 +2683,7 @@ static const PyMethodDef poly1305hash_pymethods[] = { static const PyTypeObject poly1305cls_pytype_skel = { PyVarObject_HEAD_INIT(0, 0) /* Header */ - "Poly1305Class", /* @tp_name@ */ + "_Poly1305Class", /* @tp_name@ */ sizeof(PyHeapTypeObject), /* @tp_basicsize@ */ 0, /* @tp_itemsize@ */ @@ -2718,7 +2764,7 @@ static const PyTypeObject poly1305key_pytype_skel = { 0, /* @tp_iternext@ */ 0, /* @tp_methods@ */ 0, /* @tp_members@ */ - 0, /* @tp_getset@ */ + PYGETSET(poly1305), /* @tp_getset@ */ 0, /* @tp_base@ */ 0, /* @tp_dict@ */ 0, /* @tp_descr_get@ */ @@ -2794,7 +2840,7 @@ static const PyTypeObject poly1305hash_pytype_skel = { if (n.sz != HDANCE##_INSZ) VALERR("bad input length"); \ rc = bytestring_pywrap(0, HSALSA20_OUTSZ); \ dance##_init(&dance, k.p, k.sz, 0); \ - hdance##_prf(&dance, n.p, PyString_AS_STRING(rc)); \ + hdance##_prf(&dance, n.p, BIN_PTR(rc)); \ return (rc); \ end: \ return (0); \ @@ -2866,6 +2912,27 @@ end: return (0); } +static PyObject *kxvikmeth_set(PyObject *me, PyObject *arg) +{ + kxvik_pyobj *k = (kxvik_pyobj *)me; + kludge64 t[25]; + const octet *q; + unsigned i; + struct bin in; + size_t n; + + if (!PyArg_ParseTuple(arg, "O&:set", convbin, &in)) goto end; + if (in.sz > 200) VALERR("out of range"); + q = in.p; n = in.sz; + i = 0; + while (n >= 8) { LOAD64_L_(t[i], q); i++; q += 8; n -= 8; } + if (n) VALERR("not 64-bit aligned"); + keccak1600_set(&k->s, t, i); + RETURN_ME; +end: + return (0); +} + static PyObject *kxvikmeth_extract(PyObject *me, PyObject *arg) { kxvik_pyobj *k = (kxvik_pyobj *)me; @@ -2878,7 +2945,7 @@ static PyObject *kxvikmeth_extract(PyObject *me, PyObject *arg) if (!PyArg_ParseTuple(arg, "O&:extract", convuint, &n)) goto end; if (n > 200) VALERR("out of range"); rc = bytestring_pywrap(0, n); - q = (octet *)PyString_AS_STRING(rc); + q = (octet *)BIN_PTR(rc); keccak1600_extract(&k->s, t, (n + 7)/8); i = 0; while (n > 8) { STORE64_L_(q, t[i]); i++; q += 8; n -= 8; } @@ -2905,6 +2972,7 @@ static const PyMethodDef kxvik_pymethods[] = { #define METHNAME(func) kxvikmeth_##func NAMETH(copy, "KECCAK.copy() -> KECCAK'") METH (mix, "KECCAK.mix(DATA)") + METH (set, "KECCAK.set(DATA)") METH (extract, "KECCAK.extract(NOCTETS)") NAMETH(step, "KECCAK.step()") #undef METHNAME @@ -2977,12 +3045,14 @@ static PyObject *shake_dopynew(void (*initfn)(shake_ctx *, PyObject *arg, PyObject *kw) { shake_pyobj *rc = 0; + PyObject *pobj = Py_None, *fobj = Py_None; struct bin p = { 0, 0 }, f = { 0, 0 }; static const char *const kwlist[] = { "perso", "func", 0 }; - if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&O&:new", KWLIST, - convbin, &p, convbin, &f)) - goto end; + if (!PyArg_ParseTupleAndKeywords(arg, kw, "|OO:new", KWLIST, &pobj, &fobj)) + goto end; + if (pobj != Py_None && !convbin(pobj, &p)) goto end; + if (fobj != Py_None && !convbin(fobj, &f)) goto end; rc = (shake_pyobj *)ty->tp_alloc(ty, 0); initfn(&rc->h, f.p, f.sz, p.p, p.sz); rc->st = 0; @@ -3033,7 +3103,7 @@ DOUINTCONV(SHAKEMETH_HASHU_) struct bin in; \ octet b[SZ_##W]; \ if (!PyArg_ParseTuple(arg, "O&:hashbuf" #w, convbin, &in)) goto end; \ - if (in.sz > MASK##n) TYERR("string too long"); \ + if (in.sz > MASK##n) VALERR("too large"); \ if (shake_check(me, 0)) goto end; \ STORE##W(b, in.sz); shake_hash(SHAKE_H(me), b, sizeof(b)); \ shake_hash(SHAKE_H(me), in.p, in.sz); \ @@ -3062,14 +3132,16 @@ end: return (0); } -static PyObject *shakemeth_done(PyObject *me, PyObject *arg) +static PyObject *shakemeth_done(PyObject *me, PyObject *arg, PyObject *kw) { PyObject *rc = 0; - size_t n; - if (!PyArg_ParseTuple(arg, "O&:done", convszt, &n)) goto end; + size_t n = 100 - SHAKE_H(me)->h.r/2; + static const char *const kwlist[] = { "hsz", 0 }; + if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:done", KWLIST, convszt, &n)) + goto end; if (shake_check(me, 0)) goto end; rc = bytestring_pywrap(0, n); - shake_done(SHAKE_H(me), PyString_AS_STRING(rc), n); + shake_done(SHAKE_H(me), BIN_PTR(rc), n); SHAKE_ST(me) = -1; end: return (rc); @@ -3093,7 +3165,7 @@ static PyObject *shakemeth_get(PyObject *me, PyObject *arg) if (!PyArg_ParseTuple(arg, "O&:get", convszt, &sz)) goto end; if (shake_check(me, 1)) goto end; rc = bytestring_pywrap(0, sz); - shake_get(SHAKE_H(me), PyString_AS_STRING(rc), sz); + shake_get(SHAKE_H(me), BIN_PTR(rc), sz); end: return (rc); } @@ -3106,7 +3178,7 @@ static PyObject *shakemeth_mask(PyObject *me, PyObject *arg) if (!PyArg_ParseTuple(arg, "O&:mask", convbin, &in)) goto end; if (shake_check(me, 1)) goto end; rc = bytestring_pywrap(0, in.sz); - shake_mask(SHAKE_H(me), in.p, PyString_AS_STRING(rc), in.sz); + shake_mask(SHAKE_H(me), in.p, BIN_PTR(rc), in.sz); end: return (rc); } @@ -3114,8 +3186,8 @@ end: static PyObject *shakeget_state(PyObject *me, void *hunoz) { int st = SHAKE_ST(me); - return (PyString_FromString(st == 0 ? "absorb" : - st == 1 ? "squeeze" : "dead")); + return (TEXT_FROMSTR(st == 0 ? "absorb" : + st == 1 ? "squeeze" : "dead")); } static const PyMemberDef shake_pymembers[] = { @@ -3146,7 +3218,7 @@ static const PyMethodDef shake_pymethods[] = { #undef METHBUF_ METH (hashstrz, "S.hashstrz(STRING)") NAMETH(xof, "S.xof()") - METH (done, "S.done(LEN) -> H") + KWMETH(done, "S.done([hsz = CAP]) -> H") METH (get, "S.get(LEN) -> H") METH (mask, "S.mask(M) -> C") #undef METHNAME @@ -3297,6 +3369,215 @@ static const PyTypeObject shake256_pytype_skel = { 0 /* @tp_is_gc@ */ }; +static PyTypeObject *kmac_pytype, *kmac128_pytype, *kmac256_pytype; + +static PyObject *kmac_dopynew(void (*initfn)(shake_ctx *, + const void *, size_t, + const void *, size_t), + PyTypeObject *ty, + PyObject *arg, PyObject *kw) +{ + shake_pyobj *rc = 0; + PyObject *pobj = Py_None; + struct bin k = { 0, 0 }, p = { 0, 0 }; + static const char *const kwlist[] = { "key", "perso", 0 }; + + if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O:new", KWLIST, + convbin, &k, &pobj)) + goto end; + if (pobj != Py_None && !convbin(pobj, &p)) goto end; + rc = (shake_pyobj *)ty->tp_alloc(ty, 0); + initfn(&rc->h, p.p, p.sz, k.p, k.sz); + rc->st = 0; +end: + return ((PyObject *)rc); +} + +static PyObject *kmac128_pynew(PyTypeObject *ty, + PyObject *arg, PyObject *kw) + { return (kmac_dopynew(kmac128_init, ty, arg, kw)); } + +static PyObject *kmac256_pynew(PyTypeObject *ty, + PyObject *arg, PyObject *kw) + { return (kmac_dopynew(kmac256_init, ty, arg, kw)); } + +static PyObject *kmacmeth_xof(PyObject *me) +{ + if (shake_check(me, 0)) goto end; + kmac_xof(SHAKE_H(me)); + SHAKE_ST(me) = 1; + RETURN_ME; +end: + return (0); +} + +static PyObject *kmacmeth_done(PyObject *me, PyObject *arg, PyObject *kw) +{ + PyObject *rc = 0; + size_t n = 100 - SHAKE_H(me)->h.r/2; + static const char *const kwlist[] = { "hsz", 0 }; + if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:done", KWLIST, convszt, &n)) + goto end; + if (shake_check(me, 0)) goto end; + rc = bytestring_pywrap(0, n); + kmac_done(SHAKE_H(me), BIN_PTR(rc), n); + SHAKE_ST(me) = -1; +end: + return (rc); +} + +static const PyMethodDef kmac_pymethods[] = { +#define METHNAME(func) kmacmeth_##func + NAMETH(xof, "K.xof()") + KWMETH(done, "K.done([hsz = CAP/2]) -> T") +#undef METHNAME + { 0 } +}; + +static const PyTypeObject kmac_pytype_skel = { + PyVarObject_HEAD_INIT(0, 0) /* Header */ + "KMAC", /* @tp_name@ */ + sizeof(shake_pyobj), /* @tp_basicsize@ */ + 0, /* @tp_itemsize@ */ + + 0, /* @tp_dealloc@ */ + 0, /* @tp_print@ */ + 0, /* @tp_getattr@ */ + 0, /* @tp_setattr@ */ + 0, /* @tp_compare@ */ + 0, /* @tp_repr@ */ + 0, /* @tp_as_number@ */ + 0, /* @tp_as_sequence@ */ + 0, /* @tp_as_mapping@ */ + 0, /* @tp_hash@ */ + 0, /* @tp_call@ */ + 0, /* @tp_str@ */ + 0, /* @tp_getattro@ */ + 0, /* @tp_setattro@ */ + 0, /* @tp_as_buffer@ */ + Py_TPFLAGS_DEFAULT | /* @tp_flags@ */ + Py_TPFLAGS_BASETYPE, + + /* @tp_doc@ */ + "KMAC base class.", + + 0, /* @tp_traverse@ */ + 0, /* @tp_clear@ */ + 0, /* @tp_richcompare@ */ + 0, /* @tp_weaklistoffset@ */ + 0, /* @tp_iter@ */ + 0, /* @tp_iternext@ */ + PYMETHODS(kmac), /* @tp_methods@ */ + 0, /* @tp_members@ */ + 0, /* @tp_getset@ */ + 0, /* @tp_base@ */ + 0, /* @tp_dict@ */ + 0, /* @tp_descr_get@ */ + 0, /* @tp_descr_set@ */ + 0, /* @tp_dictoffset@ */ + 0, /* @tp_init@ */ + PyType_GenericAlloc, /* @tp_alloc@ */ + abstract_pynew, /* @tp_new@ */ + 0, /* @tp_free@ */ + 0 /* @tp_is_gc@ */ +}; + +static const PyTypeObject kmac128_pytype_skel = { + PyVarObject_HEAD_INIT(0, 0) /* Header */ + "KMAC128", /* @tp_name@ */ + 0, /* @tp_basicsize@ */ + 0, /* @tp_itemsize@ */ + + 0, /* @tp_dealloc@ */ + 0, /* @tp_print@ */ + 0, /* @tp_getattr@ */ + 0, /* @tp_setattr@ */ + 0, /* @tp_compare@ */ + 0, /* @tp_repr@ */ + 0, /* @tp_as_number@ */ + 0, /* @tp_as_sequence@ */ + 0, /* @tp_as_mapping@ */ + 0, /* @tp_hash@ */ + 0, /* @tp_call@ */ + 0, /* @tp_str@ */ + 0, /* @tp_getattro@ */ + 0, /* @tp_setattro@ */ + 0, /* @tp_as_buffer@ */ + Py_TPFLAGS_DEFAULT | /* @tp_flags@ */ + Py_TPFLAGS_BASETYPE, + + /* @tp_doc@ */ + "KMAC128(KEY, [perso = STR]): KMAC XOMAC.", + + 0, /* @tp_traverse@ */ + 0, /* @tp_clear@ */ + 0, /* @tp_richcompare@ */ + 0, /* @tp_weaklistoffset@ */ + 0, /* @tp_iter@ */ + 0, /* @tp_iternext@ */ + 0, /* @tp_methods@ */ + 0, /* @tp_members@ */ + 0, /* @tp_getset@ */ + 0, /* @tp_base@ */ + 0, /* @tp_dict@ */ + 0, /* @tp_descr_get@ */ + 0, /* @tp_descr_set@ */ + 0, /* @tp_dictoffset@ */ + 0, /* @tp_init@ */ + PyType_GenericAlloc, /* @tp_alloc@ */ + kmac128_pynew, /* @tp_new@ */ + 0, /* @tp_free@ */ + 0 /* @tp_is_gc@ */ +}; + +static const PyTypeObject kmac256_pytype_skel = { + PyVarObject_HEAD_INIT(0, 0) /* Header */ + "KMAC256", /* @tp_name@ */ + 0, /* @tp_basicsize@ */ + 0, /* @tp_itemsize@ */ + + 0, /* @tp_dealloc@ */ + 0, /* @tp_print@ */ + 0, /* @tp_getattr@ */ + 0, /* @tp_setattr@ */ + 0, /* @tp_compare@ */ + 0, /* @tp_repr@ */ + 0, /* @tp_as_number@ */ + 0, /* @tp_as_sequence@ */ + 0, /* @tp_as_mapping@ */ + 0, /* @tp_hash@ */ + 0, /* @tp_call@ */ + 0, /* @tp_str@ */ + 0, /* @tp_getattro@ */ + 0, /* @tp_setattro@ */ + 0, /* @tp_as_buffer@ */ + Py_TPFLAGS_DEFAULT | /* @tp_flags@ */ + Py_TPFLAGS_BASETYPE, + + /* @tp_doc@ */ + "KMAC256(KEY, [perso = STR]): KMAC XOMAC.", + + 0, /* @tp_traverse@ */ + 0, /* @tp_clear@ */ + 0, /* @tp_richcompare@ */ + 0, /* @tp_weaklistoffset@ */ + 0, /* @tp_iter@ */ + 0, /* @tp_iternext@ */ + 0, /* @tp_methods@ */ + 0, /* @tp_members@ */ + 0, /* @tp_getset@ */ + 0, /* @tp_base@ */ + 0, /* @tp_dict@ */ + 0, /* @tp_descr_get@ */ + 0, /* @tp_descr_set@ */ + 0, /* @tp_dictoffset@ */ + 0, /* @tp_init@ */ + PyType_GenericAlloc, /* @tp_alloc@ */ + kmac256_pynew, /* @tp_new@ */ + 0, /* @tp_free@ */ + 0 /* @tp_is_gc@ */ +}; + /*----- Pseudorandom permutations -----------------------------------------*/ static PyTypeObject *gcprp_pytype, *gprp_pytype; @@ -3367,8 +3648,7 @@ static PyObject *gprp_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw) me = (PyObject *)ty->tp_alloc(ty, 0); GPRP_PRP(me) = prp; prp->init(GPRP_CTX(me), k.p, k.sz); - Py_INCREF(me); - return (me); + RETURN_ME; end: return (0); } @@ -3394,7 +3674,7 @@ static PyObject *gcprp_pywrap(const prpinfo *prp) } static PyObject *gcpget_name(PyObject *me, void *hunoz) - { return (PyString_FromString(GCPRP_PRP(me)->name)); } + { return (TEXT_FROMSTR(GCPRP_PRP(me)->name)); } static PyObject *gcpget_keysz(PyObject *me, void *hunoz) { return (keysz_pywrap(GCPRP_PRP(me)->keysz)); } static PyObject *gcpget_blksz(PyObject *me, void *hunoz) @@ -3408,7 +3688,7 @@ static PyObject *gpmeth_encrypt(PyObject *me, PyObject *arg) if (!PyArg_ParseTuple(arg, "O&:encrypt", convbin, &m)) goto end; if (m.sz != GPRP_PRP(me)->blksz) VALERR("incorrect block length"); rc = bytestring_pywrap(0, m.sz); - GPRP_PRP(me)->eblk(GPRP_CTX(me), m.p, PyString_AS_STRING(rc)); + GPRP_PRP(me)->eblk(GPRP_CTX(me), m.p, BIN_PTR(rc)); end: return (rc); } @@ -3421,7 +3701,7 @@ static PyObject *gpmeth_decrypt(PyObject *me, PyObject *arg) if (!PyArg_ParseTuple(arg, "O&:decrypt", convbin, &c)) goto end; if (c.sz != GPRP_PRP(me)->blksz) VALERR("incorrect block length"); rc = bytestring_pywrap(0, c.sz); - GPRP_PRP(me)->dblk(GPRP_CTX(me), c.p, PyString_AS_STRING(rc)); + GPRP_PRP(me)->dblk(GPRP_CTX(me), c.p, BIN_PTR(rc)); end: return (rc); } @@ -3590,6 +3870,9 @@ void algorithms_pyinit(void) INITTYPE(shake, root); INITTYPE(shake128, shake); INITTYPE(shake256, shake); + INITTYPE(kmac, shake); + INITTYPE(kmac128, kmac); + INITTYPE(kmac256, kmac); INITTYPE(gcprp, type); INITTYPE(gprp, root); addmethods(methods); @@ -3636,13 +3919,16 @@ void algorithms_pyinsert(PyObject *mod) INSERT("GMACHash", gmhash_pytype); INSERT("gcmacs", make_algtab(gmactab, sizeof(gcmac *), mac_namefn, mac_valfn)); - INSERT("Poly1305Class", poly1305cls_pytype); + INSERT("_Poly1305Class", poly1305cls_pytype); INSERT("poly1305", poly1305key_pytype); INSERT("Poly1305Hash", poly1305hash_pytype); INSERT("Keccak1600", kxvik_pytype); INSERT("Shake", shake_pytype); INSERT("Shake128", shake128_pytype); INSERT("Shake256", shake256_pytype); + INSERT("KMAC", kmac_pytype); + INSERT("KMAC128", kmac128_pytype); + INSERT("KMAC256", kmac256_pytype); INSERT("GCPRP", gcprp_pytype); INSERT("GPRP", gprp_pytype); INSERT("gcprps", make_algtab(gprptab, sizeof(gcprp *),