One of the major differences in Python 3 is that it firmly distinguishes
between binary and text strings: the former consist of small integers,
while the latter consist of Unicode scalars. The Python 3 `s#'
conversion's main purpose is to accept text strings, and though it will
also accept binary strings it's not really ideal for the purpose.
Python 3 introduces a new conversion `y#' specifically for binary
strings, though this isn't quite what we want because, for some reason,
it /doesn't/ work with bufferish objects which require explicit release.
The best answer seems to be to introduce our own custom conversion for
binary strings, so we do this here, replacing all of the binary-input
argument conversions. While we're at it, replace all of the by-steam
argument conversions using `PyObject_AsReadBuffer' too.
13 files changed:
static PyObject *gcipher_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
static const char *const kwlist[] = { "k", 0 };
static PyObject *gcipher_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
static const char *const kwlist[] = { "k", 0 };
- char *k;
- Py_ssize_t sz;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", KWLIST, &k, &sz))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:new", KWLIST, convbin, &k))
- if (keysz(sz, GCCIPHER_CC(ty)->keysz) != sz) VALERR("bad key length");
+ if (keysz(k.sz, GCCIPHER_CC(ty)->keysz) != k.sz) VALERR("bad key length");
return (gcipher_pywrap((PyObject *)ty,
return (gcipher_pywrap((PyObject *)ty,
- GC_INIT(GCCIPHER_CC(ty), k, sz)));
+ GC_INIT(GCCIPHER_CC(ty), k.p, k.sz)));
static PyObject *gcmeth_encrypt(PyObject *me, PyObject *arg)
{
static PyObject *gcmeth_encrypt(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t sz;
- if (!PyArg_ParseTuple(arg, "s#:encrypt", &p, &sz)) return (0);
- rc = bytestring_pywrap(0, sz);
- GC_ENCRYPT(GCIPHER_C(me), p, PyString_AS_STRING(rc), sz);
+ 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);
static PyObject *gcmeth_decrypt(PyObject *me, PyObject *arg)
{
static PyObject *gcmeth_decrypt(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t sz;
- if (!PyArg_ParseTuple(arg, "s#:decrypt", &p, &sz)) return (0);
- rc = bytestring_pywrap(0, sz);
- GC_DECRYPT(GCIPHER_C(me), p, PyString_AS_STRING(rc), sz);
+ 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);
static PyObject *gcmeth_setiv(PyObject *me, PyObject *arg)
{
static PyObject *gcmeth_setiv(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t sz;
- if (!PyArg_ParseTuple(arg, "s#:setiv", &p, &sz)) goto end;
+ if (!PyArg_ParseTuple(arg, "O&:setiv", convbin, &iv)) goto end;
if (!GCIPHER_C(me)->ops->setiv) VALERR("`setiv' not supported");
if (!GC_CLASS(GCIPHER_C(me))->blksz) VALERR("not a block cipher mode");
if (!GCIPHER_C(me)->ops->setiv) VALERR("`setiv' not supported");
if (!GC_CLASS(GCIPHER_C(me))->blksz) VALERR("not a block cipher mode");
- if (sz != GC_CLASS(GCIPHER_C(me))->blksz) VALERR("bad IV length");
- GC_SETIV(GCIPHER_C(me), p);
+ if (iv.sz != GC_CLASS(GCIPHER_C(me))->blksz) VALERR("bad IV length");
+ GC_SETIV(GCIPHER_C(me), iv.p);
RETURN_ME;
end:
return (0);
RETURN_ME;
end:
return (0);
PyObject *arg, PyObject *kw)
{
static const char *const kwlist[] = { "k", 0 };
PyObject *arg, PyObject *kw)
{
static const char *const kwlist[] = { "k", 0 };
- char *k;
- Py_ssize_t sz;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", KWLIST, &k, &sz))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:new", KWLIST, convbin, &k))
- if (keysz(sz, GCAEAD_AEC(ty)->keysz) != sz) VALERR("bad key length");
+ if (keysz(k.sz, GCAEAD_AEC(ty)->keysz) != k.sz) VALERR("bad key length");
return (gaeadkey_pywrap((PyObject *)ty,
return (gaeadkey_pywrap((PyObject *)ty,
- GAEAD_KEY(GCAEAD_AEC(ty), k, sz)));
+ GAEAD_KEY(GCAEAD_AEC(ty), k.p, k.sz)));
const gaead_key *k = GAEADKEY_K(me);
gaead_enc *e;
PyObject *rc = 0;
const gaead_key *k = GAEADKEY_K(me);
gaead_enc *e;
PyObject *rc = 0;
- char *n; Py_ssize_t nsz;
PyObject *hszobj = Py_None, *mszobj = Py_None, *tszobj = Py_None;
size_t hsz = 0, msz = 0, tsz = 0;
unsigned f;
PyObject *hszobj = Py_None, *mszobj = Py_None, *tszobj = Py_None;
size_t hsz = 0, msz = 0, tsz = 0;
unsigned f;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|OOO:enc", KWLIST,
- &n, &nsz, &hszobj, &mszobj, &tszobj))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|OOO:enc", KWLIST,
+ convbin, &n, &hszobj, &mszobj, &tszobj))
- if (check_aead_encdec(k->ops->c, &f, nsz,
+ if (check_aead_encdec(k->ops->c, &f, n.sz,
hszobj, &hsz, mszobj, &msz, tszobj, &tsz))
goto end;
hszobj, &hsz, mszobj, &msz, tszobj, &tsz))
goto end;
- e = GAEAD_ENC(GAEADKEY_K(me), n, nsz, hsz, msz, tsz);
+ e = GAEAD_ENC(GAEADKEY_K(me), n.p, n.sz, hsz, msz, tsz);
if (!e) VALERR("bad aead parameter combination");
rc = gaeadenc_pywrap((PyObject *)GCAEAD_ENC(Py_TYPE(me)),
e, f, hsz, msz, tsz);
if (!e) VALERR("bad aead parameter combination");
rc = gaeadenc_pywrap((PyObject *)GCAEAD_ENC(Py_TYPE(me)),
e, f, hsz, msz, tsz);
const gaead_key *k = GAEADKEY_K(me);
gaead_dec *d;
PyObject *rc = 0;
const gaead_key *k = GAEADKEY_K(me);
gaead_dec *d;
PyObject *rc = 0;
- char *n; Py_ssize_t nsz;
PyObject *hszobj = Py_None, *cszobj = Py_None, *tszobj = Py_None;
size_t hsz = 0, csz = 0, tsz = 0;
unsigned f;
PyObject *hszobj = Py_None, *cszobj = Py_None, *tszobj = Py_None;
size_t hsz = 0, csz = 0, tsz = 0;
unsigned f;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|OOO:dec", KWLIST,
- &n, &nsz, &hszobj, &cszobj, &tszobj))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|OOO:dec", KWLIST,
+ convbin, &n, &hszobj, &cszobj, &tszobj))
- if (check_aead_encdec(k->ops->c, &f, nsz,
+ if (check_aead_encdec(k->ops->c, &f, n.sz,
hszobj, &hsz, cszobj, &csz, tszobj, &tsz))
goto end;
hszobj, &hsz, cszobj, &csz, tszobj, &tsz))
goto end;
- d = GAEAD_DEC(GAEADKEY_K(me), n, nsz, hsz, csz, tsz);
+ d = GAEAD_DEC(GAEADKEY_K(me), n.p, n.sz, hsz, csz, tsz);
if (!d) VALERR("bad aead parameter combination");
rc = gaeaddec_pywrap((PyObject *)GCAEAD_DEC(Py_TYPE(me)),
d, f, hsz, csz, tsz);
if (!d) VALERR("bad aead parameter combination");
rc = gaeaddec_pywrap((PyObject *)GCAEAD_DEC(Py_TYPE(me)),
d, f, hsz, csz, tsz);
static PyObject *gaeameth_hash(PyObject *me, PyObject *arg)
{
static PyObject *gaeameth_hash(PyObject *me, PyObject *arg)
{
- char *h; Py_ssize_t hsz;
- if (!PyArg_ParseTuple(arg, "s#:hash", &h, &hsz)) return (0);
- if (gaeadaad_hash(me, h, hsz)) return (0);
+ if (!PyArg_ParseTuple(arg, "O&:hash", convbin, &h)) return (0);
+ if (gaeadaad_hash(me, h.p, h.sz)) return (0);
#define GAEAMETH_HASHBUF_(n, W, w) \
static PyObject *gaeameth_hashbuf##w(PyObject *me, PyObject *arg) \
{ \
#define GAEAMETH_HASHBUF_(n, W, w) \
static PyObject *gaeameth_hashbuf##w(PyObject *me, PyObject *arg) \
{ \
- char *p; Py_ssize_t sz; octet b[SZ_##W]; \
- if (!PyArg_ParseTuple(arg, "s#:hashbuf" #w, &p, &sz)) goto end; \
- if (sz > MASK##n) TYERR("string too long"); \
- STORE##W(b, sz); if (gaeadaad_hash(me, b, sizeof(b))) goto end; \
- if (gaeadaad_hash(me, p, sz)) goto end; \
+ 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"); \
+ 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; \
end: \
return (0); \
RETURN_ME; \
end: \
return (0); \
{
static const char *const kwlist[] = { "nonce", "hsz", "msz", "tsz", 0 };
gaeadenc_pyobj *ge = (gaeadenc_pyobj *)me;
{
static const char *const kwlist[] = { "nonce", "hsz", "msz", "tsz", 0 };
gaeadenc_pyobj *ge = (gaeadenc_pyobj *)me;
- char *n; Py_ssize_t nsz;
PyObject *hszobj = Py_None, *mszobj = Py_None, *tszobj = Py_None;
size_t hsz = 0, msz = 0, tsz = 0;
unsigned f;
PyObject *hszobj = Py_None, *mszobj = Py_None, *tszobj = Py_None;
size_t hsz = 0, msz = 0, tsz = 0;
unsigned f;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|OOO:enc", KWLIST,
- &n, &nsz, &hszobj, &mszobj, &tszobj))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|OOO:enc", KWLIST,
+ convbin, &n, &hszobj, &mszobj, &tszobj))
- if (check_aead_encdec(ge->e->ops->c, &f, nsz,
+ if (check_aead_encdec(ge->e->ops->c, &f, n.sz,
hszobj, &hsz, mszobj, &msz, tszobj, &tsz))
goto end;
hszobj, &hsz, mszobj, &msz, tszobj, &tsz))
goto end;
- if (GAEAD_REINIT(ge->e, n, nsz, hsz, msz, tsz))
+ if (GAEAD_REINIT(ge->e, n.p, n.sz, hsz, msz, tsz))
VALERR("bad aead parameter combination");
gaea_sever(&ge->aad);
ge->f = f; ge->hsz = hsz; ge->msz = msz; ge->tsz = tsz;
VALERR("bad aead parameter combination");
gaea_sever(&ge->aad);
ge->f = f; ge->hsz = hsz; ge->msz = msz; ge->tsz = tsz;
static PyObject *gaeemeth_encrypt(PyObject *me, PyObject *arg)
{
gaeadenc_pyobj *ge = (gaeadenc_pyobj *)me;
static PyObject *gaeemeth_encrypt(PyObject *me, PyObject *arg)
{
gaeadenc_pyobj *ge = (gaeadenc_pyobj *)me;
- char *m; Py_ssize_t msz;
char *c = 0; size_t csz; buf b;
int err;
PyObject *rc = 0;
char *c = 0; size_t csz; buf b;
int err;
PyObject *rc = 0;
- if (!PyArg_ParseTuple(arg, "s#:encrypt", &m, &msz)) goto end;
+ if (!PyArg_ParseTuple(arg, "O&:encrypt", convbin, &m)) goto end;
if (ge->f&AEADF_AADFIRST) {
if ((ge->f&AEADF_PCHSZ) && (ge->aad ? ge->aad->hlen : 0) != ge->hsz)
VALERR("header doesn't match precommitted length");
gaea_invalidate(ge->aad);
}
if (ge->f&AEADF_AADFIRST) {
if ((ge->f&AEADF_PCHSZ) && (ge->aad ? ge->aad->hlen : 0) != ge->hsz)
VALERR("header doesn't match precommitted length");
gaea_invalidate(ge->aad);
}
- if ((ge->f&AEADF_PCMSZ) && msz > ge->msz - ge->mlen)
+ if ((ge->f&AEADF_PCMSZ) && m.sz > ge->msz - ge->mlen)
VALERR("too large for precommitted message length");
VALERR("too large for precommitted message length");
- csz = msz + ge->e->ops->c->bufsz; c = xmalloc(csz); buf_init(&b, c, csz);
- err = GAEAD_ENCRYPT(ge->e, m, msz, &b); assert(!err); (void)err;
- buf_flip(&b); rc = bytestring_pywrapbuf(&b); ge->mlen += msz;
+ csz = m.sz + ge->e->ops->c->bufsz; c = xmalloc(csz); buf_init(&b, c, csz);
+ err = GAEAD_ENCRYPT(ge->e, m.p, m.sz, &b); assert(!err); (void)err;
+ buf_flip(&b); rc = bytestring_pywrapbuf(&b); ge->mlen += m.sz;
end:
xfree(c);
return (rc);
end:
xfree(c);
return (rc);
{
static const char *const kwlist[] = { "nonce", "hsz", "csz", "tsz", 0 };
gaeaddec_pyobj *gd = (gaeaddec_pyobj *)me;
{
static const char *const kwlist[] = { "nonce", "hsz", "csz", "tsz", 0 };
gaeaddec_pyobj *gd = (gaeaddec_pyobj *)me;
- char *n; Py_ssize_t nsz;
PyObject *hszobj = Py_None, *cszobj = Py_None, *tszobj = Py_None;
size_t hsz = 0, csz = 0, tsz = 0;
unsigned f;
PyObject *hszobj = Py_None, *cszobj = Py_None, *tszobj = Py_None;
size_t hsz = 0, csz = 0, tsz = 0;
unsigned f;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|OOO:enc", KWLIST,
- &n, &nsz, &hszobj, &cszobj, &tszobj))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|OOO:enc", KWLIST,
+ convbin, &n, &hszobj, &cszobj, &tszobj))
- if (check_aead_encdec(gd->d->ops->c, &f, nsz,
+ if (check_aead_encdec(gd->d->ops->c, &f, n.sz,
hszobj, &hsz, cszobj, &csz, tszobj, &tsz))
goto end;
hszobj, &hsz, cszobj, &csz, tszobj, &tsz))
goto end;
- if (GAEAD_REINIT(gd->d, n, nsz, hsz, csz, tsz))
+ if (GAEAD_REINIT(gd->d, n.p, n.sz, hsz, csz, tsz))
VALERR("bad aead parameter combination");
gaea_sever(&gd->aad);
gd->f = f; gd->hsz = hsz; gd->csz = csz; gd->tsz = tsz;
VALERR("bad aead parameter combination");
gaea_sever(&gd->aad);
gd->f = f; gd->hsz = hsz; gd->csz = csz; gd->tsz = tsz;
static PyObject *gaedmeth_decrypt(PyObject *me, PyObject *arg)
{
gaeaddec_pyobj *gd = (gaeaddec_pyobj *)me;
static PyObject *gaedmeth_decrypt(PyObject *me, PyObject *arg)
{
gaeaddec_pyobj *gd = (gaeaddec_pyobj *)me;
- char *c; Py_ssize_t csz;
char *m = 0; size_t msz; buf b;
int err;
PyObject *rc = 0;
char *m = 0; size_t msz; buf b;
int err;
PyObject *rc = 0;
- if (!PyArg_ParseTuple(arg, "s#:decrypt", &c, &csz)) goto end;
+ if (!PyArg_ParseTuple(arg, "O&:decrypt", convbin, &c)) goto end;
if (gd->f&AEADF_AADFIRST) {
if ((gd->f&AEADF_PCHSZ) && (gd->aad ? gd->aad->hlen : 0) != gd->hsz)
VALERR("header doesn't match precommitted length");
gaea_invalidate(gd->aad);
}
if (gd->f&AEADF_AADFIRST) {
if ((gd->f&AEADF_PCHSZ) && (gd->aad ? gd->aad->hlen : 0) != gd->hsz)
VALERR("header doesn't match precommitted length");
gaea_invalidate(gd->aad);
}
- if ((gd->f&AEADF_PCMSZ) && csz > gd->csz - gd->clen)
+ if ((gd->f&AEADF_PCMSZ) && c.sz > gd->csz - gd->clen)
VALERR("too large for precommitted message length");
VALERR("too large for precommitted message length");
- msz = csz + gd->d->ops->c->bufsz; m = xmalloc(msz); buf_init(&b, m, msz);
- err = GAEAD_DECRYPT(gd->d, c, csz, &b); assert(!err); (void)err;
- buf_flip(&b); rc = bytestring_pywrapbuf(&b); gd->clen += csz;
+ msz = c.sz + gd->d->ops->c->bufsz; m = xmalloc(msz); buf_init(&b, m, msz);
+ err = GAEAD_DECRYPT(gd->d, c.p, c.sz, &b); assert(!err); (void)err;
+ buf_flip(&b); rc = bytestring_pywrapbuf(&b); gd->clen += c.sz;
end:
xfree(m);
return (rc);
end:
xfree(m);
return (rc);
static const char *const kwlist[] = { "tag", "aad", 0 };
gaeaddec_pyobj *gd = (gaeaddec_pyobj *)me;
PyObject *aad = Py_None;
static const char *const kwlist[] = { "tag", "aad", 0 };
gaeaddec_pyobj *gd = (gaeaddec_pyobj *)me;
PyObject *aad = Py_None;
- char *t; Py_ssize_t tsz;
char *m = 0; size_t msz; buf b;
int err;
PyObject *rc = 0;
char *m = 0; size_t msz; buf b;
int err;
PyObject *rc = 0;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O:done", KWLIST,
- &t, &tsz, &aad))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O:done", KWLIST,
+ convbin, &t, &aad))
goto end;
if (aad != Py_None &&
!PyObject_TypeCheck(aad,
goto end;
if (aad != Py_None &&
!PyObject_TypeCheck(aad,
VALERR("header doesn't match precommitted length");
if ((gd->f&AEADF_PCMSZ) && gd->clen != gd->csz)
VALERR("message doesn't match precommitted length");
VALERR("header doesn't match precommitted length");
if ((gd->f&AEADF_PCMSZ) && gd->clen != gd->csz)
VALERR("message doesn't match precommitted length");
- if ((gd->f&AEADF_PCTSZ) && tsz != gd->tsz)
+ if ((gd->f&AEADF_PCTSZ) && t.sz != gd->tsz)
VALERR("tag length doesn't match precommitted value");
VALERR("tag length doesn't match precommitted value");
- if (keysz(tsz, gd->d->ops->c->tagsz) != tsz) VALERR("bad tag length");
+ if (keysz(t.sz, gd->d->ops->c->tagsz) != t.sz) VALERR("bad tag length");
msz = gd->d->ops->c->bufsz; m = xmalloc(msz); buf_init(&b, m, msz);
msz = gd->d->ops->c->bufsz; m = xmalloc(msz); buf_init(&b, m, msz);
- err = GAEAD_DONE(gd->d, aad == Py_None ? 0 : GAEADAAD_A(aad), &b, t, tsz);
+ err = GAEAD_DONE(gd->d, aad == Py_None ? 0 : GAEADAAD_A(aad),
+ &b, t.p, t.sz);
assert(err >= 0);
if (!err) VALERR("decryption failed");
buf_flip(&b); rc = bytestring_pywrapbuf(&b);
assert(err >= 0);
if (!err) VALERR("decryption failed");
buf_flip(&b); rc = bytestring_pywrapbuf(&b);
static PyObject *ghmeth_hash(PyObject *me, PyObject *arg)
{
static PyObject *ghmeth_hash(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t sz;
- if (!PyArg_ParseTuple(arg, "s#:hash", &p, &sz)) return (0);
- GH_HASH(GHASH_H(me), p, sz);
+ struct bin m;
+ if (!PyArg_ParseTuple(arg, "O&:hash", convbin, &m)) return (0);
+ GH_HASH(GHASH_H(me), m.p, m.sz);
#define GHMETH_HASHBUF_(n, W, w) \
static PyObject *ghmeth_hashbuf##w(PyObject *me, PyObject *arg) \
{ \
#define GHMETH_HASHBUF_(n, W, w) \
static PyObject *ghmeth_hashbuf##w(PyObject *me, PyObject *arg) \
{ \
- char *p; \
- Py_ssize_t sz; \
- if (!PyArg_ParseTuple(arg, "s#:hashbuf" #w, &p, &sz)) goto end; \
- if (sz > MASK##n) TYERR("string too long"); \
- GH_HASHBUF##W(GHASH_H(me), p, sz); \
+ struct bin in; \
+ if (!PyArg_ParseTuple(arg, "O&:hashbuf" #w, convbin, &in)) goto end; \
+ if (in.sz > MASK##n) TYERR("string too long"); \
+ GH_HASHBUF##W(GHASH_H(me), in.p, in.sz); \
RETURN_ME; \
end: \
return (0); \
RETURN_ME; \
end: \
return (0); \
static PyObject *gmac_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
static const char *const kwlist[] = { "k", 0 };
static PyObject *gmac_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
static const char *const kwlist[] = { "k", 0 };
- char *k;
- Py_ssize_t sz;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", KWLIST, &k, &sz))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:new", KWLIST, convbin, &k))
- if (keysz(sz, GCMAC_CM(ty)->keysz) != sz) VALERR("bad key length");
+ if (keysz(k.sz, GCMAC_CM(ty)->keysz) != k.sz) VALERR("bad key length");
return (gmac_pywrap((PyObject *)ty,
return (gmac_pywrap((PyObject *)ty,
- GM_KEY(GCMAC_CM(ty), k, sz)));
+ GM_KEY(GCMAC_CM(ty), k.p, k.sz)));
static const char *const kwlist[] = { "mask", 0 };
poly1305key_pyobj *pk = (poly1305key_pyobj *)ty;
poly1305hash_pyobj *ph;
static const char *const kwlist[] = { "mask", 0 };
poly1305key_pyobj *pk = (poly1305key_pyobj *)ty;
poly1305hash_pyobj *ph;
- char *m = 0;
- Py_ssize_t sz;
+ struct bin m = { 0, 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "|s#:new", KWLIST, &m, &sz))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:new", KWLIST, convbin, &m))
- if (m && sz != POLY1305_MASKSZ) VALERR("bad mask length");
+ if (m.p && m.sz != POLY1305_MASKSZ) VALERR("bad mask length");
ph = PyObject_NEW(poly1305hash_pyobj, ty);
ph->f = 0;
ph = PyObject_NEW(poly1305hash_pyobj, ty);
ph->f = 0;
- if (m) ph->f |= f_mask;
- poly1305_macinit(&ph->ctx, &pk->k, m);
+ if (m.p) ph->f |= f_mask;
+ poly1305_macinit(&ph->ctx, &pk->k, m.p);
Py_INCREF(ty);
return ((PyObject *)ph);
end:
Py_INCREF(ty);
return ((PyObject *)ph);
end:
{
static const char *const kwlist[] = { "k", 0 };
poly1305key_pyobj *pk;
{
static const char *const kwlist[] = { "k", 0 };
poly1305key_pyobj *pk;
- char *k;
- Py_ssize_t sz;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", KWLIST, &k, &sz))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:new", KWLIST, convbin, &k))
- if (keysz(sz, poly1305_keysz) != sz) VALERR("bad key length");
+ 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 = newtype(ty, 0, 0);
pk->ty.ht_name = PyString_FromString("poly1305(keyed)");
pk->ty.ht_type.tp_new = poly1305hash_pynew;
typeready(&pk->ty.ht_type);
pk->ty.ht_type.tp_new = poly1305hash_pynew;
typeready(&pk->ty.ht_type);
- poly1305_keyinit(&pk->k, k, sz);
+ poly1305_keyinit(&pk->k, k.p, k.sz);
return ((PyObject *)pk);
end:
return ((PyObject *)pk);
end:
static PyObject *polymeth_hash(PyObject *me, PyObject *arg)
{
static PyObject *polymeth_hash(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t sz;
- if (!PyArg_ParseTuple(arg, "s#:hash", &p, &sz)) return (0);
- poly1305_hash(P1305_CTX(me), p, sz);
+ struct bin m;
+ if (!PyArg_ParseTuple(arg, "O&:hash", convbin, &m)) return (0);
+ poly1305_hash(P1305_CTX(me), m.p, m.sz);
#define POLYMETH_HASHBUF_(n, W, w) \
static PyObject *polymeth_hashbuf##w(PyObject *me, PyObject *arg) \
{ \
#define POLYMETH_HASHBUF_(n, W, w) \
static PyObject *polymeth_hashbuf##w(PyObject *me, PyObject *arg) \
{ \
- char *p; \
- Py_ssize_t sz; \
- if (!PyArg_ParseTuple(arg, "s#:hashbuf" #w, &p, &sz)) goto end; \
- if (sz > MASK##n) TYERR("string too long"); \
- STORE##W(b, sz); poly1305_hash(P1305_CTX(me), b, sizeof(b)); \
- poly1305_hash(P1305_CTX(me), p, sz); \
+ if (!PyArg_ParseTuple(arg, "O&:hashbuf" #w, convbin, &in)) goto end; \
+ if (in.sz > MASK##n) TYERR("string too long"); \
+ STORE##W(b, in.sz); poly1305_hash(P1305_CTX(me), b, sizeof(b)); \
+ poly1305_hash(P1305_CTX(me), in.p, in.sz); \
RETURN_ME; \
end: \
return (0); \
RETURN_ME; \
end: \
return (0); \
static PyObject *meth_##hdance##_prf(PyObject *me, PyObject *arg) \
{ \
dance##_ctx dance; \
static PyObject *meth_##hdance##_prf(PyObject *me, PyObject *arg) \
{ \
dance##_ctx dance; \
- char *k, *n; \
- Py_ssize_t ksz, nsz; \
- if (!PyArg_ParseTuple(arg, "s#s#:" #hdance "_prf", \
- &k, &ksz, &n, &nsz)) \
+ if (!PyArg_ParseTuple(arg, "O&O&:" #hdance "_prf", \
+ convbin, &k, convbin, &n)) \
- if (ksz != keysz(ksz, dance##_keysz)) VALERR("bad key length"); \
- if (nsz != HDANCE##_INSZ) VALERR("bad input length"); \
+ if (k.sz != keysz(k.sz, dance##_keysz)) VALERR("bad key length"); \
+ if (n.sz != HDANCE##_INSZ) VALERR("bad input length"); \
rc = bytestring_pywrap(0, HSALSA20_OUTSZ); \
rc = bytestring_pywrap(0, HSALSA20_OUTSZ); \
- dance##_init(&dance, k, ksz, 0); \
- hdance##_prf(&dance, n, PyString_AS_STRING(rc)); \
+ dance##_init(&dance, k.p, k.sz, 0); \
+ hdance##_prf(&dance, n.p, PyString_AS_STRING(rc)); \
return (rc); \
end: \
return (0); \
return (rc); \
end: \
return (0); \
const octet *q;
octet buf[8];
unsigned i;
const octet *q;
octet buf[8];
unsigned i;
+ struct bin in;
+ size_t n;
- if (!PyArg_ParseTuple(arg, "s#:mix", &p, &n)) goto end;
- if (n > 200) VALERR("out of range");
- q = (const octet *)p;
+ if (!PyArg_ParseTuple(arg, "O&:mix", 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) {
i = 0;
while (n > 8) { LOAD64_L_(t[i], q); i++; q += 8; n -= 8; }
if (n) {
PyObject *arg, PyObject *kw)
{
shake_pyobj *rc = 0;
PyObject *arg, PyObject *kw)
{
shake_pyobj *rc = 0;
- char *p = 0, *f = 0;
- Py_ssize_t psz = 0, fsz = 0;
+ struct bin p = { 0, 0 }, f = { 0, 0 };
static const char *const kwlist[] = { "perso", "func", 0 };
static const char *const kwlist[] = { "perso", "func", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "|s#s#:new", KWLIST,
- &p, &psz, &f, &fsz))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&O&:new", KWLIST,
+ convbin, &p, convbin, &f))
goto end;
rc = (shake_pyobj *)ty->tp_alloc(ty, 0);
goto end;
rc = (shake_pyobj *)ty->tp_alloc(ty, 0);
- initfn(&rc->h, f, fsz, p, psz);
+ initfn(&rc->h, f.p, f.sz, p.p, p.sz);
rc->st = 0;
end:
return ((PyObject *)rc);
rc->st = 0;
end:
return ((PyObject *)rc);
static PyObject *shakemeth_hash(PyObject *me, PyObject *arg)
{
static PyObject *shakemeth_hash(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t sz;
- if (!PyArg_ParseTuple(arg, "s#:hash", &p, &sz)) return (0);
+ struct bin m;
+ if (!PyArg_ParseTuple(arg, "O&:hash", convbin, &m)) return (0);
if (shake_check(me, 0)) return (0);
if (shake_check(me, 0)) return (0);
- shake_hash(SHAKE_H(me), p, sz);
+ shake_hash(SHAKE_H(me), m.p, m.sz);
#define SHAKEMETH_HASHBUF_(n, W, w) \
static PyObject *shakemeth_hashbuf##w(PyObject *me, PyObject *arg) \
{ \
#define SHAKEMETH_HASHBUF_(n, W, w) \
static PyObject *shakemeth_hashbuf##w(PyObject *me, PyObject *arg) \
{ \
- char *p; \
- Py_ssize_t sz; \
- if (!PyArg_ParseTuple(arg, "s#:hashbuf" #w, &p, &sz)) goto end; \
- if (sz > MASK##n) TYERR("string too long"); \
+ if (!PyArg_ParseTuple(arg, "O&:hashbuf" #w, convbin, &in)) goto end; \
+ if (in.sz > MASK##n) TYERR("string too long"); \
if (shake_check(me, 0)) goto end; \
if (shake_check(me, 0)) goto end; \
- STORE##W(b, sz); shake_hash(SHAKE_H(me), b, sizeof(b)); \
- shake_hash(SHAKE_H(me), p, sz); \
+ STORE##W(b, in.sz); shake_hash(SHAKE_H(me), b, sizeof(b)); \
+ shake_hash(SHAKE_H(me), in.p, in.sz); \
RETURN_ME; \
end: \
return (0); \
RETURN_ME; \
end: \
return (0); \
static PyObject *shakemeth_mask(PyObject *me, PyObject *arg)
{
PyObject *rc = 0;
static PyObject *shakemeth_mask(PyObject *me, PyObject *arg)
{
PyObject *rc = 0;
- char *p; Py_ssize_t sz;
- if (!PyArg_ParseTuple(arg, "s#:mask", &p, &sz)) goto end;
+ if (!PyArg_ParseTuple(arg, "O&:mask", convbin, &in)) goto end;
if (shake_check(me, 1)) goto end;
if (shake_check(me, 1)) goto end;
- rc = bytestring_pywrap(0, sz);
- shake_mask(SHAKE_H(me), p, PyString_AS_STRING(rc), sz);
+ rc = bytestring_pywrap(0, in.sz);
+ shake_mask(SHAKE_H(me), in.p, PyString_AS_STRING(rc), in.sz);
static PyObject *gprp_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
static const char *const kwlist[] = { "key", 0 };
static PyObject *gprp_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
static const char *const kwlist[] = { "key", 0 };
- char *k;
- Py_ssize_t sz;
const prpinfo *prp = GCPRP_PRP(ty);
PyObject *me;
const prpinfo *prp = GCPRP_PRP(ty);
PyObject *me;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", KWLIST, &k, &sz))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:new", KWLIST, convbin, &k))
- if (keysz(sz, prp->keysz) != sz) VALERR("bad key length");
+ if (keysz(k.sz, prp->keysz) != k.sz) VALERR("bad key length");
me = (PyObject *)ty->tp_alloc(ty, 0);
GPRP_PRP(me) = prp;
me = (PyObject *)ty->tp_alloc(ty, 0);
GPRP_PRP(me) = prp;
- prp->init(GPRP_CTX(me), k, sz);
+ prp->init(GPRP_CTX(me), k.p, k.sz);
Py_INCREF(me);
return (me);
end:
Py_INCREF(me);
return (me);
end:
static PyObject *gpmeth_encrypt(PyObject *me, PyObject *arg)
{
static PyObject *gpmeth_encrypt(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t n;
- if (!PyArg_ParseTuple(arg, "s#:encrypt", &p, &n)) goto end;
- if (n != GPRP_PRP(me)->blksz) VALERR("incorrect block length");
- rc = bytestring_pywrap(0, n);
- GPRP_PRP(me)->eblk(GPRP_CTX(me), p, PyString_AS_STRING(rc));
+ 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));
end:
return (rc);
}
static PyObject *gpmeth_decrypt(PyObject *me, PyObject *arg)
{
end:
return (rc);
}
static PyObject *gpmeth_decrypt(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t n;
- if (!PyArg_ParseTuple(arg, "s#:decrypt", &p, &n)) goto end;
- if (n != GPRP_PRP(me)->blksz) VALERR("incorrect block length");
- rc = bytestring_pywrap(0, n);
- GPRP_PRP(me)->dblk(GPRP_CTX(me), p, PyString_AS_STRING(rc));
+ 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));
static PyObject *rbuf_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
static PyObject *rbuf_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
- char *p, *q;
- Py_ssize_t n;
+ struct bin in;
+ void *q;
buf_pyobj *me = 0;
static const char *const kwlist[] = { "data", 0 };
buf_pyobj *me = 0;
static const char *const kwlist[] = { "data", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", KWLIST, &p, &n))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:new", KWLIST, convbin, &in))
- q = xmalloc(n);
- memcpy(q, p, n);
+ q = xmalloc(in.sz);
+ memcpy(q, in.p, in.sz);
me = (buf_pyobj *)ty->tp_alloc(ty, 0);
me->sub = 0;
me = (buf_pyobj *)ty->tp_alloc(ty, 0);
me->sub = 0;
- buf_init(&me->b, q, n);
+ buf_init(&me->b, q, in.sz);
end:
return ((PyObject *)me);
}
end:
return ((PyObject *)me);
}
static PyObject *wbmeth_put(PyObject *me, PyObject *arg)
{
static PyObject *wbmeth_put(PyObject *me, PyObject *arg)
{
- void *p;
- Py_ssize_t n;
- if (!PyArg_ParseTuple(arg, "s#:put", &p, &n)) return (0);
- ensure(me, n);
- buf_put(BUF_B(me), p, n); assert(BOK(BUF_B(me)));
+ struct bin in;
+ if (!PyArg_ParseTuple(arg, "O&:put", convbin, &in)) return (0);
+ ensure(me, in.sz);
+ buf_put(BUF_B(me), in.p, in.sz); assert(BOK(BUF_B(me)));
#define WBMETH_PUTBLK_(n, W, w) \
static PyObject *wbmeth_putblk##w(PyObject *me, PyObject *arg) \
{ \
#define WBMETH_PUTBLK_(n, W, w) \
static PyObject *wbmeth_putblk##w(PyObject *me, PyObject *arg) \
{ \
- char *p; \
- Py_ssize_t sz; \
- if (!PyArg_ParseTuple(arg, "s#:putblk" #w, &p, &sz)) goto end; \
- if (MASK##W && sz > MASK##W) VALERR("too large"); \
- ensure(me, sz + SZ_##n); \
- buf_putmem##w(BUF_B(me), p, sz); assert(BOK(BUF_B(me))); \
+ struct bin in; \
+ if (!PyArg_ParseTuple(arg, "O&:putblk" #w, convbin, &in)) goto end; \
+ if (MASK##W && in.sz > MASK##W) VALERR("too large"); \
+ ensure(me, in.sz + SZ_##n); \
+ buf_putmem##w(BUF_B(me), in.p, in.sz); assert(BOK(BUF_B(me))); \
RETURN_ME; \
end: \
return (0); \
RETURN_ME; \
end: \
return (0); \
static PyObject *bytestring_pynew(PyTypeObject *ty,
PyObject *arg, PyObject *kw)
{
static PyObject *bytestring_pynew(PyTypeObject *ty,
PyObject *arg, PyObject *kw)
{
- const char *p;
- Py_ssize_t n;
static const char *const kwlist[] = { "data", 0 };
static const char *const kwlist[] = { "data", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", KWLIST, &p, &n))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:new", KWLIST, convbin, &in))
- return (dowrap(ty, p, n));
+ return (dowrap(ty, in.p, in.sz));
}
static PyObject *meth_ctstreq(PyObject *me, PyObject *arg)
{
}
static PyObject *meth_ctstreq(PyObject *me, PyObject *arg)
{
- char *p, *q;
- Py_ssize_t psz, qsz;
- if (!PyArg_ParseTuple(arg, "s#s#:ctstreq", &p, &psz, &q, &qsz))
+ struct bin s0, s1;
+ if (!PyArg_ParseTuple(arg, "O&O&:ctstreq", convbin, &s0 , convbin, &s1))
- if (psz == qsz && ct_memeq(p, q, psz)) RETURN_TRUE;
+ if (s0.sz == s1.sz && ct_memeq(s0.p, s1.p, s0.sz)) RETURN_TRUE;
else RETURN_FALSE;
end:
return (0);
else RETURN_FALSE;
end:
return (0);
static PyObject *bytestring_pyrichcompare(PyObject *me,
PyObject *you, int op)
{
static PyObject *bytestring_pyrichcompare(PyObject *me,
PyObject *you, int op)
{
- void *mystr, *yourstr;
- Py_ssize_t mylen, yourlen, minlen;
- if (!PyString_Check(me) || !PyString_Check(you)) RETURN_NOTIMPL;
- mystr = PyString_AS_STRING(me); mylen = PyString_GET_SIZE(me);
- yourstr = PyString_AS_STRING(you); yourlen = PyString_GET_SIZE(you);
+ s0.p = PyString_AS_STRING(me); s0.sz = PyString_GET_SIZE(me);
+ if (!convbin(you, &s1)) { PyErr_Clear(); RETURN_NOTIMPL; }
switch (op) {
case Py_EQ:
switch (op) {
case Py_EQ:
- b = mylen == yourlen && ct_memeq(mystr, yourstr, mylen);
+ b = s0.sz == s1.sz && ct_memeq(s0.p, s1.p, s1.sz);
- b = mylen != yourlen || !ct_memeq(mystr, yourstr, mylen);
+ b = s0.sz != s1.sz || !ct_memeq(s0.p, s1.p, s1.sz);
- minlen = mylen < yourlen ? mylen : yourlen;
- b = memcmp(mystr, yourstr, minlen);
- if (!b) b = mylen < yourlen ? -1 : mylen > yourlen ? +1 : 0;
+ minlen = s0.sz < s1.sz ? s0.sz : s1.sz;
+ b = memcmp(s0.p, s1.p, minlen);
+ if (!b) b = s0.sz < s1.sz ? -1 : s0.sz > s1.sz ? +1 : 0;
switch (op) {
case Py_LT: b = b < 0; break;
case Py_LE: b = b <= 0; break;
switch (op) {
case Py_LT: b = b < 0; break;
case Py_LE: b = b <= 0; break;
static PyObject *bytestring_pyconcat(PyObject *x, PyObject *y)
{
static PyObject *bytestring_pyconcat(PyObject *x, PyObject *y)
{
- const void *xv; Py_ssize_t xsz;
- const void *yv; Py_ssize_t ysz;
PyObject *z = 0; char *zp; size_t zsz;
PyObject *z = 0; char *zp; size_t zsz;
- if (PyObject_AsReadBuffer(x, &xv, &xsz) ||
- PyObject_AsReadBuffer(y, &yv, &ysz))
- goto end;
- zsz = (size_t)xsz + (size_t)ysz;
- if (xsz < 0 || ysz < 0 || zsz < xsz) VALERR("too long");
+ if (!convbin(x, &xx) || !convbin(y, &yy)) goto end;
+ zsz = (size_t)xx.sz + (size_t)yy.sz;
+ if (xx.sz < 0 || yy.sz < 0 || zsz < xx.sz) VALERR("too long");
z = bytestring_pywrap(0, zsz); zp = PyString_AS_STRING(z);
z = bytestring_pywrap(0, zsz); zp = PyString_AS_STRING(z);
- memcpy(zp, xv, xsz); memcpy(zp + xsz, yv, ysz);
+ memcpy(zp, xx.p, xx.sz); memcpy(zp + xx.sz, yy.p, yy.sz);
#define BINOP(name, op) \
static PyObject *bytestring_py##name(PyObject *x, PyObject *y) { \
#define BINOP(name, op) \
static PyObject *bytestring_py##name(PyObject *x, PyObject *y) { \
const unsigned char *xp, *yp; \
unsigned char *zp; \
const unsigned char *xp, *yp; \
unsigned char *zp; \
int i; \
PyObject *rc = 0; \
int i; \
PyObject *rc = 0; \
- if (PyObject_AsReadBuffer(x, &xv, &xsz) || \
- PyObject_AsReadBuffer(y, &yv, &ysz)) \
- goto end; \
- if (xsz != ysz) VALERR("length mismatch"); \
- rc = bytestring_pywrap(0, xsz); \
- xp = xv; yp = yv; zp = (unsigned char *)PyString_AS_STRING(rc); \
- for (i = xsz; i > 0; i--) *zp++ = *xp++ op *yp++; \
+ if (!convbin(x, &xx) || !convbin(y, &yy)) goto end; \
+ if (xx.sz != yy.sz) VALERR("length mismatch"); \
+ rc = bytestring_pywrap(0, xx.sz); \
+ xp = xx.p; yp = yy.p; zp = (unsigned char *)PyString_AS_STRING(rc); \
+ for (i = xx.sz; i > 0; i--) *zp++ = *xp++ op *yp++; \
#define UNOP(name, op) \
static PyObject *bytestring_py##name(PyObject *x) { \
#define UNOP(name, op) \
static PyObject *bytestring_py##name(PyObject *x) { \
const unsigned char *xp; \
unsigned char *zp; \
const unsigned char *xp; \
unsigned char *zp; \
int i; \
PyObject *rc = 0; \
int i; \
PyObject *rc = 0; \
- if (PyObject_AsReadBuffer(x, &xv, &xsz)) goto end; \
- rc = bytestring_pywrap(0, xsz); \
- xp = xv; zp = (unsigned char *)PyString_AS_STRING(rc); \
- for (i = xsz; i > 0; i--) *zp++ = op *xp++; \
+ if (!convbin(x, &xx)) goto end; \
+ rc = bytestring_pywrap(0, xx.sz); \
+ xp = xx.p; zp = (unsigned char *)PyString_AS_STRING(rc); \
+ for (i = xx.sz; i > 0; i--) *zp++ = op *xp++; \
static PyObject *epmeth_frombuf(PyObject *me, PyObject *arg)
{
static PyObject *epmeth_frombuf(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t sz;
PyObject *rc = 0;
ec pp = EC_INIT;
PyObject *rc = 0;
ec pp = EC_INIT;
- if (!PyArg_ParseTuple(arg, "s#:frombuf", &p, &sz)) goto end;
- buf_init(&b, p, sz);
+ if (!PyArg_ParseTuple(arg, "O&:frombuf", convbin, &in)) goto end;
+ buf_init(&b, (/*unconst*/ void *)in.p, in.sz);
if (buf_getec(&b, &pp)) VALERR("malformed data");
rc = Py_BuildValue("(NN)", ecpt_pywrapout(me, &pp),
bytestring_pywrapbuf(&b));
if (buf_getec(&b, &pp)) VALERR("malformed data");
rc = Py_BuildValue("(NN)", ecpt_pywrapout(me, &pp),
bytestring_pywrapbuf(&b));
static PyObject *epmeth_fromraw(PyObject *me, PyObject *arg)
{
static PyObject *epmeth_fromraw(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t len;
buf b;
PyObject *rc = 0;
ec_curve *cc;
ec pp = EC_INIT;
buf b;
PyObject *rc = 0;
ec_curve *cc;
ec pp = EC_INIT;
- if (!PyArg_ParseTuple(arg, "s#:fromraw", &me, &p, &len)) return (0);
- buf_init(&b, p, len);
+ if (!PyArg_ParseTuple(arg, "O&:fromraw", convbin, &in)) return (0);
+ buf_init(&b, (/*unconst*/ void *)in.p, in.sz);
cc = ECCURVE_C(me);
if (ec_getraw(cc, &b, &pp))
VALERR("bad point");
cc = ECCURVE_C(me);
if (ec_getraw(cc, &b, &pp))
VALERR("bad point");
static PyObject *epmeth_os2ecp(PyObject *me, PyObject *arg, PyObject *kw)
{
static PyObject *epmeth_os2ecp(PyObject *me, PyObject *arg, PyObject *kw)
{
- char *p;
- Py_ssize_t len;
buf b;
PyObject *rc = 0;
ec_curve *cc;
buf b;
PyObject *rc = 0;
ec_curve *cc;
ec pp = EC_INIT;
static const char *const kwlist[] = { "buf", "flags", 0 };
ec pp = EC_INIT;
static const char *const kwlist[] = { "buf", "flags", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:os2ecp", KWLIST,
- &p, &len, convuint, &f))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:os2ecp", KWLIST,
+ convbin, &in, convuint, &f))
+ buf_init(&b, (/*unconst*/ void *)in.p, in.sz);
cc = ECCURVE_C(me);
if (ec_os2ecp(cc, f, &b, &pp)) VALERR("bad point");
EC_IN(cc, &pp, &pp);
cc = ECCURVE_C(me);
if (ec_os2ecp(cc, f, &b, &pp)) VALERR("bad point");
EC_IN(cc, &pp, &pp);
int rc = -1;
PyObject *y = 0, *z = 0, *t = 0;
mp *xx = 0;
int rc = -1;
PyObject *y = 0, *z = 0, *t = 0;
mp *xx = 0;
Py_ssize_t n;
qd_parse qd;
Py_ssize_t n;
qd_parse qd;
getecptout(p, x);
goto fix;
} else if (PyString_Check(x)) {
getecptout(p, x);
goto fix;
} else if (PyString_Check(x)) {
- if (PyObject_AsReadBuffer(x, &q, &n))
- goto end;
- qd.p = q;
+ qd.p = PyString_AS_STRING(x);
qd.e = 0;
if (!ec_ptparse(&qd, p))
VALERR(qd.e);
qd.e = 0;
if (!ec_ptparse(&qd, p))
VALERR(qd.e);
unsigned ql, pl;
unsigned steps = 0;
dsa_seed ds;
unsigned ql, pl;
unsigned steps = 0;
dsa_seed ds;
- char *k;
- Py_ssize_t ksz;
struct excinfo exc = EXCINFO_INIT;
pypgev evt = { { 0 } };
static const char *const kwlist[] =
struct excinfo exc = EXCINFO_INIT;
pypgev evt = { { 0 } };
static const char *const kwlist[] =
PyObject *rc = 0;
evt.exc = &exc;
PyObject *rc = 0;
evt.exc = &exc;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&s#|O&O&:gendsa", KWLIST,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&O&|O&O&:gendsa", KWLIST,
convuint, &pl, convuint, &ql,
convuint, &pl, convuint, &ql,
- &k, &ksz, convpgev, &evt,
- convuint, &steps))
+ convbin, &k,
+ convpgev, &evt, convuint, &steps))
- if (dsa_gen(&dp, ql, pl, steps, k, ksz, &ds, evt.ev.proc, evt.ev.ctx))
+ if (dsa_gen(&dp, ql, pl, steps, k.p, k.sz, &ds, evt.ev.proc, evt.ev.ctx))
PGENERR(&exc);
rc = Py_BuildValue("(NNl)", fginfo_pywrap(&dp, dhinfo_pytype),
bytestring_pywrap(ds.p, ds.sz), (long)ds.count);
PGENERR(&exc);
rc = Py_BuildValue("(NNl)", fginfo_pywrap(&dp, dhinfo_pytype),
bytestring_pywrap(ds.p, ds.sz), (long)ds.count);
static PyObject *gemeth_frombuf(PyObject *me, PyObject *arg)
{
buf b;
static PyObject *gemeth_frombuf(PyObject *me, PyObject *arg)
{
buf b;
- char *p;
- Py_ssize_t n;
- if (!PyArg_ParseTuple(arg, "s#:frombuf", &p, &n)) return (0);
+ if (!PyArg_ParseTuple(arg, "O&:frombuf", convbin, &in)) return (0);
+ buf_init(&b, (/*unconst*/ void *)in.p, in.sz);
x = G_CREATE(g);
if (G_FROMBUF(g, &b, x)) VALERR("invalid data");
return (Py_BuildValue("(NN)", ge_pywrap(me, x), bytestring_pywrapbuf(&b)));
x = G_CREATE(g);
if (G_FROMBUF(g, &b, x)) VALERR("invalid data");
return (Py_BuildValue("(NN)", ge_pywrap(me, x), bytestring_pywrapbuf(&b)));
static PyObject *gemeth_fromraw(PyObject *me, PyObject *arg)
{
buf b;
static PyObject *gemeth_fromraw(PyObject *me, PyObject *arg)
{
buf b;
- char *p;
- Py_ssize_t n;
- if (!PyArg_ParseTuple(arg, "s#:fromraw", &p, &n)) return (0);
+ if (!PyArg_ParseTuple(arg, "O&:fromraw", convbin, &in)) return (0);
+ buf_init(&b, (/*unconst*/ void *)in.p, in.sz);
x = G_CREATE(g);
if (G_FROMRAW(g, &b, x)) VALERR("invalid data");
return (Py_BuildValue("(NN)", ge_pywrap(me, x), bytestring_pywrapbuf(&b)));
x = G_CREATE(g);
if (G_FROMRAW(g, &b, x)) VALERR("invalid data");
return (Py_BuildValue("(NN)", ge_pywrap(me, x), bytestring_pywrapbuf(&b)));
static PyObject *kdmeth_lock(PyObject *me, PyObject *arg)
{
static PyObject *kdmeth_lock(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t n;
PyObject *rc = 0;
key_data *kd;
PyObject *rc = 0;
key_data *kd;
- if (!PyArg_ParseTuple(arg, "s#:lock", &p, &n))
+ if (!PyArg_ParseTuple(arg, "O&:lock", convbin, &pp))
- key_lock(&kd, KEYDATA_KD(me), p, n);
+ key_lock(&kd, KEYDATA_KD(me), pp.p, pp.sz);
rc = keydata_pywrap(kd);
end:
return (rc);
rc = keydata_pywrap(kd);
end:
return (rc);
static PyObject *kdmeth_decode(PyObject *me, PyObject *arg)
{
static PyObject *kdmeth_decode(PyObject *me, PyObject *arg)
{
- const char *p;
- Py_ssize_t n;
key_data *kd;
PyObject *rc = 0;
key_data *kd;
PyObject *rc = 0;
- if (!PyArg_ParseTuple(arg, "s#:decode", &p, &n)) goto end;
- if ((kd = key_decode(p, n)) == 0) KEYERR(KERR_MALFORMED);
- rc = keydata_pywrap(kd);
+ if (!PyArg_ParseTuple(arg, "O&:decode", convbin, &in)) goto end;
+ if ((kd = key_decode(in.p, in.sz)) == 0) KEYERR(KERR_MALFORMED);
+ rc = keydata_pywrap(kd);
static PyObject *keydatabin_pynew(PyTypeObject *ty,
PyObject *arg, PyObject *kw)
{
static PyObject *keydatabin_pynew(PyTypeObject *ty,
PyObject *arg, PyObject *kw)
{
- char *p;
- Py_ssize_t n;
unsigned f = 0;
keydata_pyobj *me = 0;
static const char *const kwlist[] = { "key", "flags", 0 };
unsigned f = 0;
keydata_pyobj *me = 0;
static const char *const kwlist[] = { "key", "flags", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:new", KWLIST,
- &p, &n, convflags, &f))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", KWLIST,
+ convbin, &in, convflags, &f))
goto end;
me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
goto end;
me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
- me->kd = key_newbinary(f & ~KF_ENCMASK, p, n);
+ me->kd = key_newbinary(f & ~KF_ENCMASK, in.p, in.sz);
end:
return ((PyObject *)me);
}
end:
return ((PyObject *)me);
}
static PyObject *keydataenc_pynew(PyTypeObject *ty,
PyObject *arg, PyObject *kw)
{
static PyObject *keydataenc_pynew(PyTypeObject *ty,
PyObject *arg, PyObject *kw)
{
- char *p;
- Py_ssize_t n;
unsigned f = 0;
keydata_pyobj *me = 0;
static const char *const kwlist[] = { "key", "flags", 0 };
unsigned f = 0;
keydata_pyobj *me = 0;
static const char *const kwlist[] = { "key", "flags", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:new", KWLIST,
- &p, &n, convflags, &f))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", KWLIST,
+ convbin, &in, convflags, &f))
goto end;
me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
goto end;
me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
- me->kd = key_newencrypted(f & ~KF_ENCMASK, p, n);
+ me->kd = key_newencrypted(f & ~KF_ENCMASK, in.p, in.sz);
end:
return ((PyObject *)me);
}
end:
return ((PyObject *)me);
}
static PyObject *kdemeth_lock(PyObject *me, PyObject *arg)
{
static PyObject *kdemeth_lock(PyObject *me, PyObject *arg)
{
- char *hunoz;
- Py_ssize_t hukairz;
- if (!PyArg_ParseTuple(arg, "s#:lock", &hunoz, &hukairz)) goto end;
+ struct bin hunoz;
+ if (!PyArg_ParseTuple(arg, "O&:lock", convbin, &hunoz)) goto end;
KEYERR(KERR_WRONGTYPE);
end:
return (0);
KEYERR(KERR_WRONGTYPE);
end:
return (0);
static PyObject *kdemeth_unlock(PyObject *me, PyObject *arg)
{
static PyObject *kdemeth_unlock(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t n;
int err;
PyObject *rc = 0;
key_data *kd;
int err;
PyObject *rc = 0;
key_data *kd;
- if (!PyArg_ParseTuple(arg, "s#:unlock", &p, &n))
+ if (!PyArg_ParseTuple(arg, "O&:unlock", convbin, &pp))
- if ((err = key_unlock(&kd, KEYDATA_KD(me), p, n)) != 0)
+ if ((err = key_unlock(&kd, KEYDATA_KD(me), pp.p, pp.sz)) != 0)
KEYERR(err);
rc = keydata_pywrap(kd);
end:
KEYERR(err);
rc = keydata_pywrap(kd);
end:
static PyObject *ty##meth_frombuf(PyObject *me, PyObject *arg) \
{ \
buf b; \
static PyObject *ty##meth_frombuf(PyObject *me, PyObject *arg) \
{ \
buf b; \
- char *p; \
- Py_ssize_t sz; \
PyObject *rc = 0; \
mp *x; \
\
PyObject *rc = 0; \
mp *x; \
\
- if (!PyArg_ParseTuple(arg, "s#:frombuf", &p, &sz)) goto end; \
- buf_init(&b, p, sz); \
+ if (!PyArg_ParseTuple(arg, "O&:frombuf", convbin, &in)) goto end; \
+ buf_init(&b, (/*unconst*/ void *)in.p, in.sz); \
if ((x = buf_getmp(&b)) == 0) VALERR("malformed data"); \
rc = Py_BuildValue("(NN)", ty##_pywrap(x), \
bytestring_pywrapbuf(&b)); \
if ((x = buf_getmp(&b)) == 0) VALERR("malformed data"); \
rc = Py_BuildValue("(NN)", ty##_pywrap(x), \
bytestring_pywrapbuf(&b)); \
#define LOADOP(pre, name) \
static PyObject *pre##meth_##name(PyObject *me, PyObject *arg) \
{ \
#define LOADOP(pre, name) \
static PyObject *pre##meth_##name(PyObject *me, PyObject *arg) \
{ \
- char *p; \
- Py_ssize_t len; \
- if (!PyArg_ParseTuple(arg, "s#:" #name, &p, &len)) return (0); \
- return (pre##_pywrap(mp_##name(MP_NEW, p, len))); \
+ struct bin in; \
+ if (!PyArg_ParseTuple(arg, "O&:" #name, convbin, &in)) return (0); \
+ return (pre##_pywrap(mp_##name(MP_NEW, in.p, in.sz))); \
}
LOADOP(mp, loadl)
LOADOP(mp, loadb)
}
LOADOP(mp, loadl)
LOADOP(mp, loadb)
static PyObject *dsameth_sign(PyObject *me, PyObject *arg, PyObject *kw)
{
gdsa_sig s = GDSA_SIG_INIT;
static PyObject *dsameth_sign(PyObject *me, PyObject *arg, PyObject *kw)
{
gdsa_sig s = GDSA_SIG_INIT;
- char *p;
- Py_ssize_t n;
mp *k = 0;
PyObject *rc = 0;
static const char *const kwlist[] = { "msg", "k", 0 };
mp *k = 0;
PyObject *rc = 0;
static const char *const kwlist[] = { "msg", "k", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:sign", KWLIST,
- &p, &n, convmp, &k))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:sign", KWLIST,
+ convbin, &h, convmp, &k))
- if (n != DSA_D(me)->h->hashsz)
+ if (h.sz != DSA_D(me)->h->hashsz)
VALERR("bad message length (doesn't match hash size)");
VALERR("bad message length (doesn't match hash size)");
- gdsa_sign(DSA_D(me), &s, p, k);
+ gdsa_sign(DSA_D(me), &s, h.p, k);
rc = Py_BuildValue("(NN)", mp_pywrap(s.r), mp_pywrap(s.s));
end:
mp_drop(k);
rc = Py_BuildValue("(NN)", mp_pywrap(s.r), mp_pywrap(s.s));
end:
mp_drop(k);
static PyObject *dsameth_verify(PyObject *me, PyObject *arg)
{
static PyObject *dsameth_verify(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t n;
gdsa_sig s = GDSA_SIG_INIT;
PyObject *rc = 0;
gdsa_sig s = GDSA_SIG_INIT;
PyObject *rc = 0;
- if (!PyArg_ParseTuple(arg, "s#(O&O&):verify",
- &p, &n, convmp, &s.r, convmp, &s.s))
+ if (!PyArg_ParseTuple(arg, "O&(O&O&):verify",
+ convbin, &h, convmp, &s.r, convmp, &s.s))
- if (n != DSA_D(me)->h->hashsz)
+ if (h.sz != DSA_D(me)->h->hashsz)
VALERR("bad message length (doesn't match hash size)");
VALERR("bad message length (doesn't match hash size)");
- rc = getbool(!gdsa_verify(DSA_D(me), &s, p));
+ rc = getbool(!gdsa_verify(DSA_D(me), &s, h.p));
end:
mp_drop(s.r);
mp_drop(s.s);
end:
mp_drop(s.r);
mp_drop(s.s);
static PyObject *kcdsameth_sign(PyObject *me, PyObject *arg, PyObject *kw)
{
gkcdsa_sig s = GKCDSA_SIG_INIT;
static PyObject *kcdsameth_sign(PyObject *me, PyObject *arg, PyObject *kw)
{
gkcdsa_sig s = GKCDSA_SIG_INIT;
- char *p;
- Py_ssize_t n;
mp *k = 0;
PyObject *r = 0, *rc = 0;
static const char *const kwlist[] = { "msg", "k", 0 };
mp *k = 0;
PyObject *r = 0, *rc = 0;
static const char *const kwlist[] = { "msg", "k", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:sign", KWLIST,
- &p, &n, convmp, &k))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:sign", KWLIST,
+ convbin, &h, convmp, &k))
- if (n != DSA_D(me)->h->hashsz)
+ if (h.sz != DSA_D(me)->h->hashsz)
VALERR("bad message length (doesn't match hash size)");
r = bytestring_pywrap(0, DSA_D(me)->h->hashsz);
s.r = (octet *)PyString_AS_STRING(r);
VALERR("bad message length (doesn't match hash size)");
r = bytestring_pywrap(0, DSA_D(me)->h->hashsz);
s.r = (octet *)PyString_AS_STRING(r);
- gkcdsa_sign(DSA_D(me), &s, p, k);
+ gkcdsa_sign(DSA_D(me), &s, h.p, k);
rc = Py_BuildValue("(ON)", r, mp_pywrap(s.s));
end:
Py_XDECREF(r);
rc = Py_BuildValue("(ON)", r, mp_pywrap(s.s));
end:
Py_XDECREF(r);
static PyObject *kcdsameth_verify(PyObject *me, PyObject *arg)
{
static PyObject *kcdsameth_verify(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t n, rn;
gkcdsa_sig s = GKCDSA_SIG_INIT;
PyObject *rc = 0;
gkcdsa_sig s = GKCDSA_SIG_INIT;
PyObject *rc = 0;
- if (!PyArg_ParseTuple(arg, "s#(s#O&):verify",
- &p, &n, &s.r, &rn, convmp, &s.s))
+ if (!PyArg_ParseTuple(arg, "O&(O&O&):verify",
+ convbin, &h, convbin, &sr, convmp, &s.s))
- if (n != DSA_D(me)->h->hashsz)
+ if (h.sz != DSA_D(me)->h->hashsz)
VALERR("bad message length (doesn't match hash size)");
VALERR("bad message length (doesn't match hash size)");
- if (rn != DSA_D(me)->h->hashsz)
+ if (sr.sz != DSA_D(me)->h->hashsz)
VALERR("bad signature `r' length (doesn't match hash size)");
VALERR("bad signature `r' length (doesn't match hash size)");
- rc = getbool(!gkcdsa_verify(DSA_D(me), &s, p));
+ s.r = (/*unconst*/ octet *)sr.p;
+ rc = getbool(!gkcdsa_verify(DSA_D(me), &s, h.p));
end:
mp_drop(s.s);
return (rc);
end:
mp_drop(s.s);
return (rc);
PyObject *arg, PyObject *kw)
{
pkcs1 p1;
PyObject *arg, PyObject *kw)
{
pkcs1 p1;
- char *m, *ep;
- Py_ssize_t msz, epsz;
+ struct bin m, ep = { 0, 0 };
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
mp *x;
static const char *const kwlist[] = { "msg", "nbits", "ep", "rng", 0 };
mp *x;
static const char *const kwlist[] = { "msg", "nbits", "ep", "rng", 0 };
- p1.r = &rand_global; ep = 0; epsz = 0;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#O&|s#O&:encode", KWLIST,
- &m, &msz, convulong, &nbits,
- &ep, &epsz, convgrand, &p1.r))
+ p1.r = &rand_global;
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&|O&O&:encode", KWLIST,
+ convbin, &m, convulong, &nbits,
+ convbin, &ep, convgrand, &p1.r))
goto end;
sz = (nbits + 7)/8;
goto end;
sz = (nbits + 7)/8;
- p1.ep = ep; p1.epsz = epsz;
- if (epsz + msz + 11 > sz) VALERR("buffer underflow");
+ p1.ep = ep.p; p1.epsz = ep.sz;
+ if (ep.sz + m.sz + 11 > sz) VALERR("buffer underflow");
- x = pkcs1_cryptencode(MP_NEW, m, msz, b, sz, nbits, &p1);
+ x = pkcs1_cryptencode(MP_NEW, m.p, m.sz, b, sz, nbits, &p1);
rc = mp_pywrap(x);
end:
xfree(b);
rc = mp_pywrap(x);
end:
xfree(b);
PyObject *arg, PyObject *kw)
{
pkcs1 p1;
PyObject *arg, PyObject *kw)
{
pkcs1 p1;
- char *ep;
- Py_ssize_t epsz;
+ struct bin ep = { 0, 0 };
unsigned long nbits;
int n;
PyObject *rc = 0;
unsigned long nbits;
int n;
PyObject *rc = 0;
mp *x = 0;
static const char *const kwlist[] = { "ct", "nbits", "ep", "rng", 0 };
mp *x = 0;
static const char *const kwlist[] = { "ct", "nbits", "ep", "rng", 0 };
- p1.r = &rand_global; ep = 0; epsz = 0;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&|s#O&:decode", KWLIST,
+ p1.r = &rand_global;
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&|O&O&:decode", KWLIST,
convmp, &x, convulong, &nbits,
convmp, &x, convulong, &nbits,
- &ep, &epsz, convgrand, &p1.r))
+ convbin, &ep, convgrand, &p1.r))
goto end;
sz = (nbits + 7)/8;
goto end;
sz = (nbits + 7)/8;
- p1.ep = ep; p1.epsz = epsz;
- if (epsz + 11 > sz) VALERR("buffer underflow");
+ p1.ep = ep.p; p1.epsz = ep.sz;
+ if (ep.sz + 11 > sz) VALERR("buffer underflow");
b = xmalloc(sz);
if ((n = pkcs1_cryptdecode(x, b, sz, nbits, &p1)) < 0)
VALERR("decryption failed");
b = xmalloc(sz);
if ((n = pkcs1_cryptdecode(x, b, sz, nbits, &p1)) < 0)
VALERR("decryption failed");
PyObject *arg, PyObject *kw)
{
pkcs1 p1;
PyObject *arg, PyObject *kw)
{
pkcs1 p1;
- char *m, *ep;
- Py_ssize_t msz, epsz;
+ struct bin m, ep = { 0, 0 };
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
mp *x;
static const char *const kwlist[] = { "msg", "nbits", "ep", "rng", 0 };
mp *x;
static const char *const kwlist[] = { "msg", "nbits", "ep", "rng", 0 };
- p1.r = &rand_global; ep = 0; epsz = 0;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#O&|s#O&:encode", KWLIST,
- &m, &msz, convulong, &nbits,
- &ep, &epsz, convgrand, &p1.r))
+ p1.r = &rand_global;
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&|O&O&:encode", KWLIST,
+ convbin, &m, convulong, &nbits,
+ convbin, &ep, convgrand, &p1.r))
goto end;
sz = (nbits + 7)/8;
goto end;
sz = (nbits + 7)/8;
- p1.ep = ep; p1.epsz = epsz;
- if (epsz + msz + 11 > sz) VALERR("buffer underflow");
+ p1.ep = ep.p; p1.epsz = ep.sz;
+ if (ep.sz + m.sz + 11 > sz) VALERR("buffer underflow");
- x = pkcs1_sigencode(MP_NEW, m, msz, b, sz, nbits, &p1);
+ x = pkcs1_sigencode(MP_NEW, m.p, m.sz, b, sz, nbits, &p1);
rc = mp_pywrap(x);
end:
xfree(b);
rc = mp_pywrap(x);
end:
xfree(b);
PyObject *arg, PyObject *kw)
{
pkcs1 p1;
PyObject *arg, PyObject *kw)
{
pkcs1 p1;
- char *ep;
- Py_ssize_t epsz;
+ struct bin ep = { 0, 0 };
unsigned long nbits;
int n;
PyObject *hukairz;
unsigned long nbits;
int n;
PyObject *hukairz;
static const char *const kwlist[] =
{ "msg", "sig", "nbits", "ep", "rng", 0 };
static const char *const kwlist[] =
{ "msg", "sig", "nbits", "ep", "rng", 0 };
- p1.r = &rand_global; ep = 0; epsz = 0;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "OO&O&|s#O&:decode", KWLIST,
+ p1.r = &rand_global;
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "OO&O&|O&O&:decode", KWLIST,
&hukairz, convmp, &x, convulong, &nbits,
&hukairz, convmp, &x, convulong, &nbits,
- &ep, &epsz, convgrand, &p1.r))
+ convbin, &ep, convgrand, &p1.r))
goto end;
sz = (nbits + 7)/8;
goto end;
sz = (nbits + 7)/8;
- p1.ep = ep; p1.epsz = epsz;
- if (epsz + 10 > sz) VALERR("buffer underflow");
+ p1.ep = ep.p; p1.epsz = ep.sz;
+ if (ep.sz + 10 > sz) VALERR("buffer underflow");
b = xmalloc(sz);
if ((n = pkcs1_sigdecode(x, 0, 0, b, sz, nbits, &p1)) < 0)
VALERR("verification failed");
b = xmalloc(sz);
if ((n = pkcs1_sigdecode(x, 0, 0, b, sz, nbits, &p1)) < 0)
VALERR("verification failed");
PyObject *arg, PyObject *kw)
{
oaep o;
PyObject *arg, PyObject *kw)
{
oaep o;
- char *m, *ep;
- Py_ssize_t msz, epsz;
+ struct bin m, ep = { 0, 0 };
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
static const char *const kwlist[] =
{ "msg", "nbits", "mgf", "hash", "ep", "rng", 0 };
static const char *const kwlist[] =
{ "msg", "nbits", "mgf", "hash", "ep", "rng", 0 };
- o.r = &rand_global; o.cc = &sha_mgf; o.ch = &sha; ep = 0; epsz = 0;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#O&|O&O&s#O&:encode", KWLIST,
- &m, &msz, convulong, &nbits,
+ o.r = &rand_global; o.cc = &sha_mgf; o.ch = &sha;
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&|O&O&O&O&:encode",
+ KWLIST,
+ convbin, &m, convulong, &nbits,
convgccipher, &o.cc,
convgchash, &o.ch,
convgccipher, &o.cc,
convgchash, &o.ch,
convgrand, &o.r))
goto end;
sz = (nbits + 7)/8;
convgrand, &o.r))
goto end;
sz = (nbits + 7)/8;
- o.ep = ep; o.epsz = epsz;
- if (2 * o.ch->hashsz + 2 + msz > sz) VALERR("buffer underflow");
+ o.ep = ep.p; o.epsz = ep.sz;
+ if (2 * o.ch->hashsz + 2 + m.sz > sz) VALERR("buffer underflow");
- x = oaep_encode(MP_NEW, m, msz, b, sz, nbits, &o);
+ x = oaep_encode(MP_NEW, m.p, m.sz, b, sz, nbits, &o);
rc = mp_pywrap(x);
end:
xfree(b);
rc = mp_pywrap(x);
end:
xfree(b);
PyObject *arg, PyObject *kw)
{
oaep o;
PyObject *arg, PyObject *kw)
{
oaep o;
- char *ep;
- Py_ssize_t epsz;
+ struct bin ep = { 0, 0 };
unsigned long nbits;
int n;
PyObject *rc = 0;
unsigned long nbits;
int n;
PyObject *rc = 0;
static const char *const kwlist[] =
{ "ct", "nbits", "mgf", "hash", "ep", "rng", 0 };
static const char *const kwlist[] =
{ "ct", "nbits", "mgf", "hash", "ep", "rng", 0 };
- o.r = &rand_global; o.cc = &sha_mgf; o.ch = &sha; ep = 0; epsz = 0;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&|O&O&s#O&:decode", KWLIST,
+ o.r = &rand_global; o.cc = &sha_mgf; o.ch = &sha;
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&|O&O&O&O&:decode", KWLIST,
convmp, &x, convulong, &nbits,
convgccipher, &o.cc,
convgchash, &o.ch,
convmp, &x, convulong, &nbits,
convgccipher, &o.cc,
convgchash, &o.ch,
convgrand, &o.r))
goto end;
sz = (nbits + 7)/8;
convgrand, &o.r))
goto end;
sz = (nbits + 7)/8;
- o.ep = ep; o.epsz = epsz;
+ o.ep = ep.p; o.epsz = ep.sz;
if (2 * o.ch->hashsz > sz) VALERR("buffer underflow");
b = xmalloc(sz);
if ((n = oaep_decode(x, b, sz, nbits, &o)) < 0)
if (2 * o.ch->hashsz > sz) VALERR("buffer underflow");
b = xmalloc(sz);
if ((n = oaep_decode(x, b, sz, nbits, &o)) < 0)
PyObject *arg, PyObject *kw)
{
pss p;
PyObject *arg, PyObject *kw)
{
pss p;
- char *m;
- Py_ssize_t msz;
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
{ "msg", "nbits", "mgf", "hash", "saltsz", "rng", 0 };
p.cc = &sha_mgf; p.ch = &sha; p.r = &rand_global; p.ssz = (size_t)-1;
{ "msg", "nbits", "mgf", "hash", "saltsz", "rng", 0 };
p.cc = &sha_mgf; p.ch = &sha; p.r = &rand_global; p.ssz = (size_t)-1;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#O&|O&O&O&O&:encode", KWLIST,
- &m, &msz, convulong, &nbits,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&|O&O&O&O&:encode", KWLIST,
+ convbin, &m, convulong, &nbits,
convgccipher, &p.cc,
convgchash, &p.ch,
convszt, &p.ssz,
convgccipher, &p.cc,
convgchash, &p.ch,
convszt, &p.ssz,
if (p.ssz == (size_t)-1) p.ssz = p.ch->hashsz;
if (p.ch->hashsz + p.ssz + 2 > sz) VALERR("buffer underflow");
b = xmalloc(sz);
if (p.ssz == (size_t)-1) p.ssz = p.ch->hashsz;
if (p.ch->hashsz + p.ssz + 2 > sz) VALERR("buffer underflow");
b = xmalloc(sz);
- x = pss_encode(MP_NEW, m, msz, b, sz, nbits, &p);
+ x = pss_encode(MP_NEW, m.p, m.sz, b, sz, nbits, &p);
rc = mp_pywrap(x);
end:
xfree(b);
rc = mp_pywrap(x);
end:
xfree(b);
PyObject *arg, PyObject *kw)
{
pss p;
PyObject *arg, PyObject *kw)
{
pss p;
- char *m;
- Py_ssize_t msz;
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
unsigned long nbits;
PyObject *rc = 0;
octet *b = 0;
{ "msg", "sig", "nbits", "mgf", "hash", "saltsz", "rng", 0 };
p.cc = &sha_mgf; p.ch = &sha; p.r = &rand_global; p.ssz = (size_t)-1;
{ "msg", "sig", "nbits", "mgf", "hash", "saltsz", "rng", 0 };
p.cc = &sha_mgf; p.ch = &sha; p.r = &rand_global; p.ssz = (size_t)-1;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#O&O&|O&O&O&O&:decode", KWLIST,
- &m, &msz, convmp, &x, convulong, &nbits,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&O&|O&O&O&O&:decode",
+ KWLIST,
+ convbin, &m, convmp, &x,
+ convulong, &nbits,
convgccipher, &p.cc,
convgchash, &p.ch,
convszt, &p.ssz,
convgccipher, &p.cc,
convgchash, &p.ch,
convszt, &p.ssz,
if (p.ssz == (size_t)-1) p.ssz = p.ch->hashsz;
if (p.ch->hashsz + p.ssz + 2 > sz) VALERR("buffer underflow");
b = xmalloc(sz);
if (p.ssz == (size_t)-1) p.ssz = p.ch->hashsz;
if (p.ch->hashsz + p.ssz + 2 > sz) VALERR("buffer underflow");
b = xmalloc(sz);
- if ((n = pss_decode(x, m, msz, b, sz, nbits, &p)) < 0)
+ if ((n = pss_decode(x, m.p, m.sz, b, sz, nbits, &p)) < 0)
VALERR("verification failed");
rc = Py_None; Py_INCREF(rc);
end:
VALERR("verification failed");
rc = Py_None; Py_INCREF(rc);
end:
#define DEFXDH(X, x) \
static PyObject *meth_##x(PyObject *me, PyObject *arg) \
{ \
#define DEFXDH(X, x) \
static PyObject *meth_##x(PyObject *me, PyObject *arg) \
{ \
- const char *k, *p; \
- Py_ssize_t ksz, psz; \
- if (!PyArg_ParseTuple(arg, "s#s#:" #x, &k, &ksz, &p, &psz)) \
+ if (!PyArg_ParseTuple(arg, "O&O&:" #x, convbin, &k, convbin, &p)) \
- if (ksz != X##_KEYSZ) VALERR("bad key length"); \
- if (psz != X##_PUBSZ) VALERR("bad public length"); \
+ if (k.sz != X##_KEYSZ) VALERR("bad key length"); \
+ if (p.sz != X##_PUBSZ) VALERR("bad public length"); \
rc = bytestring_pywrap(0, X##_OUTSZ); \
rc = bytestring_pywrap(0, X##_OUTSZ); \
- x((octet *)PyString_AS_STRING(rc), \
- (const octet *)k, (const octet *)p); \
+ x((octet *)PyString_AS_STRING(rc), k.p, p.p); \
return (rc); \
end: \
return (0); \
return (rc); \
end: \
return (0); \
\
static PyObject *meth_##ed##_pubkey(PyObject *me, PyObject *arg) \
{ \
\
static PyObject *meth_##ed##_pubkey(PyObject *me, PyObject *arg) \
{ \
- const char *k; \
- Py_ssize_t ksz; \
- if (!PyArg_ParseTuple(arg, "s#:" #ed "_pubkey", &k, &ksz)) \
+ if (!PyArg_ParseTuple(arg, "O&:" #ed "_pubkey", convbin, &k)) \
goto end; \
rc = bytestring_pywrap(0, ED##_PUBSZ); \
goto end; \
rc = bytestring_pywrap(0, ED##_PUBSZ); \
- ed##_pubkey((octet *)PyString_AS_STRING(rc), k, ksz); \
+ ed##_pubkey((octet *)PyString_AS_STRING(rc), k.p, k.sz); \
return (rc); \
end: \
return (0); \
return (rc); \
end: \
return (0); \
static PyObject *meth_##ed##_sign(PyObject *me, PyObject *arg, \
PyObject *kw) \
{ \
static PyObject *meth_##ed##_sign(PyObject *me, PyObject *arg, \
PyObject *kw) \
{ \
- const char *k, *p = 0, *c = 0, *m; \
- Py_ssize_t ksz, psz, csz = 0, msz; \
+ struct bin k, p = { 0, 0}, c = { 0, 0 }, m; \
int ph = phdflt; \
PyObject *rc = 0; \
octet pp[ED##_PUBSZ]; \
static const char *const kwlist[] = \
{ "key", "msg", "pub", "perso", "phflag", 0 }; \
if (!PyArg_ParseTupleAndKeywords(arg, kw, \
int ph = phdflt; \
PyObject *rc = 0; \
octet pp[ED##_PUBSZ]; \
static const char *const kwlist[] = \
{ "key", "msg", "pub", "perso", "phflag", 0 }; \
if (!PyArg_ParseTupleAndKeywords(arg, kw, \
- "s#s#|s#s#O&:" #ed "_sign", \
+ "O&O&|O&O&O&:" #ed "_sign", \
- &k, &ksz, &m, &msz, &p, &psz, \
- &c, &csz, convbool, &ph)) \
+ convbin, &k, convbin, &m, \
+ convbin, &p, convbin, &c, \
+ convbool, &ph)) \
- if (p && psz != ED##_PUBSZ) VALERR("bad public length"); \
- if (c && csz > ED##_MAXPERSOSZ) \
+ if (p.p && p.sz != ED##_PUBSZ) VALERR("bad public length"); \
+ if (c.p && c.sz > ED##_MAXPERSOSZ) \
VALERR("personalization string too long"); \
VALERR("personalization string too long"); \
- if (c && ph == -1) ph = 0; \
- if (!p) { p = (const char *)pp; ed##_pubkey(pp, k, ksz); } \
+ if (c.p && ph == -1) ph = 0; \
+ if (!p.p) { p.p = pp; ed##_pubkey(pp, k.p, k.sz); } \
rc = bytestring_pywrap(0, ED##_SIGSZ); \
rc = bytestring_pywrap(0, ED##_SIGSZ); \
- ed##sigver##_sign((octet *)PyString_AS_STRING(rc), k, ksz, \
- (const octet *)p, ph, c, csz, m, msz); \
+ ed##sigver##_sign((octet *)PyString_AS_STRING(rc), k.p, k.sz, \
+ p.p, ph, c.p, c.sz, m.p, m.sz); \
return (rc); \
end: \
return (0); \
return (rc); \
end: \
return (0); \
static PyObject *meth_##ed##_verify(PyObject *me, \
PyObject *arg, PyObject *kw) \
{ \
static PyObject *meth_##ed##_verify(PyObject *me, \
PyObject *arg, PyObject *kw) \
{ \
- const char *p, *c = 0, *m, *s; \
- Py_ssize_t psz, csz = 0, msz, ssz; \
+ struct bin p, c = { 0, 0 }, m, s; \
int ph = phdflt; \
PyObject *rc = 0; \
static const char *const kwlist[] = \
{ "pub", "msg", "sig", "perso", "phflag", 0 }; \
if (!PyArg_ParseTupleAndKeywords(arg, kw, \
int ph = phdflt; \
PyObject *rc = 0; \
static const char *const kwlist[] = \
{ "pub", "msg", "sig", "perso", "phflag", 0 }; \
if (!PyArg_ParseTupleAndKeywords(arg, kw, \
- "s#s#s#|s#O&:" #ed "_verify", \
+ "O&O&O&|O&O&:" #ed "_verify", \
- &p, &psz, &m, &msz, &s, &ssz, \
- &c, &csz, convbool, &ph)) \
+ convbin, &p, convbin, &m, \
+ convbin, &s, \
+ convbin, &c, convbool, &ph)) \
- if (psz != ED##_PUBSZ) VALERR("bad public length"); \
- if (ssz != ED##_SIGSZ) VALERR("bad signature length"); \
- if (c && csz > ED##_MAXPERSOSZ) \
+ if (p.sz != ED##_PUBSZ) VALERR("bad public length"); \
+ if (s.sz != ED##_SIGSZ) VALERR("bad signature length"); \
+ if (c.p && c.sz > ED##_MAXPERSOSZ) \
VALERR("personalization string too long"); \
VALERR("personalization string too long"); \
- if (c && ph == -1) ph = 0; \
- rc = getbool(!ed##sigver##_verify((const octet *)p, ph, c, csz, \
- m, msz, (const octet *)s)); \
+ if (c.p && ph == -1) ph = 0; \
+ rc = getbool(!ed##sigver##_verify(p.p, ph, c.p, c.sz, \
+ m.p, m.sz, s.p)); \
return (rc); \
end: \
return (0); \
return (rc); \
end: \
return (0); \
+int convbin(PyObject *o, void *pp)
+{
+ struct bin *r = pp;
+
+ if (PyString_Check(o)) {
+ r->p = PyString_AS_STRING(o);
+ r->sz = PyString_GET_SIZE(o);
+ return (1);
+ }
+ if (PyUnicode_Check(o)) {
+ o = _PyUnicode_AsDefaultEncodedString(o, 0);
+ if (!o) return (0);
+ r->p = PyString_AS_STRING(o);
+ r->sz = PyString_GET_SIZE(o);
+ return (1);
+ }
+ return (PyObject_AsReadBuffer(o, &r->p, &r->sz) ? 0 : 1);
+}
+
/*----- Miscellaneous utilities -------------------------------------------*/
PyObject *abstract_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
/*----- Miscellaneous utilities -------------------------------------------*/
PyObject *abstract_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
/* Input conversion functions for standard kinds of objects, with overflow
* checking where applicable.
*/
/* Input conversion functions for standard kinds of objects, with overflow
* checking where applicable.
*/
+struct bin { const void *p; Py_ssize_t sz; };
extern int convulong(PyObject *, void *); /* unsigned long */
extern int convuint(PyObject *, void *); /* unsigned int */
extern int convszt(PyObject *, void *); /* size_t */
extern int convbool(PyObject *, void *); /* bool */
extern int convulong(PyObject *, void *); /* unsigned long */
extern int convuint(PyObject *, void *); /* unsigned int */
extern int convszt(PyObject *, void *); /* size_t */
extern int convbool(PyObject *, void *); /* bool */
+extern int convbin(PyObject *, void *); /* read buffer holding bytes */
/* Output conversions. */
extern PyObject *getbool(int); /* bool */
/* Output conversions. */
extern PyObject *getbool(int); /* bool */
static PyObject *grmeth_seedblock(PyObject *me, PyObject *arg)
{
static PyObject *grmeth_seedblock(PyObject *me, PyObject *arg)
{
- char *p;
- Py_ssize_t n;
- if (!PyArg_ParseTuple(arg, "s#:seedblock", &p, &n) ||
+ if (!PyArg_ParseTuple(arg, "O&:seedblock", convbin, &in) ||
grand_check(me) || checkop(r, GRAND_SEEDBLOCK, "seedblock"))
goto end;
grand_check(me) || checkop(r, GRAND_SEEDBLOCK, "seedblock"))
goto end;
- r->ops->misc(r, GRAND_SEEDBLOCK, p, (size_t)n);
+ r->ops->misc(r, GRAND_SEEDBLOCK, in.p, (size_t)in.sz);
RETURN_ME;
end:
return (0);
RETURN_ME;
end:
return (0);
static PyObject *grmeth_mask(PyObject *me, PyObject *arg)
{
grand *r = GRAND_R(me);
static PyObject *grmeth_mask(PyObject *me, PyObject *arg)
{
grand *r = GRAND_R(me);
- char *p, *q;
- Py_ssize_t sz;
+ struct bin in;
+ const octet *p; size_t n;
+ octet *q;
- if (!PyArg_ParseTuple(arg, "s#:mask", &p, &sz)) return (0);
+ if (!PyArg_ParseTuple(arg, "O&:mask", convbin, &in)) return (0);
if (grand_check(me)) return (0);
if (grand_check(me)) return (0);
- rc = bytestring_pywrap(0, sz);
- q = PyString_AS_STRING(rc);
- GR_FILL(r, q, sz);
- while (sz--) *q++ ^= *p++;
+ rc = bytestring_pywrap(0, in.sz);
+ q = (octet *)PyString_AS_STRING(rc);
+ GR_FILL(r, q, in.sz);
+ p = in.p; n = in.sz; while (n--) *q++ ^= *p++;
static PyObject *trmeth_add(PyObject *me, PyObject *arg)
{
grand *r = GRAND_R(me);
static PyObject *trmeth_add(PyObject *me, PyObject *arg)
{
grand *r = GRAND_R(me);
- char *p; Py_ssize_t n; unsigned goodbits;
- if (!PyArg_ParseTuple(arg, "s#O&:add", &p, &n, convuint, &goodbits))
+ struct bin in; unsigned goodbits;
+ if (!PyArg_ParseTuple(arg, "O&O&:add", convbin, &in, convuint, &goodbits))
- r->ops->misc(r, RAND_ADD, p, (size_t)n, goodbits);
+ r->ops->misc(r, RAND_ADD, in.p, (size_t)in.sz, goodbits);
RETURN_ME;
}
static PyObject *trmeth_key(PyObject *me, PyObject *arg)
{
grand *r = GRAND_R(me);
RETURN_ME;
}
static PyObject *trmeth_key(PyObject *me, PyObject *arg)
{
grand *r = GRAND_R(me);
- char *p; Py_ssize_t n;
- if (!PyArg_ParseTuple(arg, "s#:key", &p, &n)) return (0);
- r->ops->misc(r, RAND_KEY, p, (size_t)n);
+ struct bin k;
+ if (!PyArg_ParseTuple(arg, "O&:key", convbin, &k)) return (0);
+ r->ops->misc(r, RAND_KEY, k.p, (size_t)k.sz);
{
const gccrand_info *info = GCCRAND_INFO(ty);
static const char *const kwlist[] = { "key", 0 };
{
const gccrand_info *info = GCCRAND_INFO(ty);
static const char *const kwlist[] = { "key", 0 };
- char *k;
- Py_ssize_t n;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", KWLIST, &k, &n))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:new", KWLIST, convbin, &k))
- if (keysz(n, info->keysz) != n) VALERR("bad key length");
- return (grand_dopywrap(ty, info->func(k, n), f_freeme));
+ if (keysz(k.sz, info->keysz) != k.sz) VALERR("bad key length");
+ return (grand_dopywrap(ty, info->func(k.p, k.sz), f_freeme));
const gccrand_info *info = GCCRAND_INFO(ty);
uint32 i = 0;
static const char *const kwlist[] = { "key", "i", 0 };
const gccrand_info *info = GCCRAND_INFO(ty);
uint32 i = 0;
static const char *const kwlist[] = { "key", "i", 0 };
- char *k;
- Py_ssize_t n;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#O&:new", KWLIST,
- &k, &n, convu32, &i))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&:new", KWLIST,
+ convbin, &k, convu32, &i))
- if (keysz(n, info->keysz) != n) VALERR("bad key length");
+ if (keysz(k.sz, info->keysz) != k.sz) VALERR("bad key length");
return (grand_dopywrap(ty,
return (grand_dopywrap(ty,
- ((gcirand_func *)info->func)(k, n, i),
+ ((gcirand_func *)info->func)(k.p, k.sz, i),
f_freeme));
end:
return (0);
f_freeme));
end:
return (0);
{
const gccrand_info *info = GCCRAND_INFO(ty);
static const char *const kwlist[] = { "key", "nonce", 0 };
{
const gccrand_info *info = GCCRAND_INFO(ty);
static const char *const kwlist[] = { "key", "nonce", 0 };
- char *k, *n;
- Py_ssize_t ksz, nsz;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#s#:new", KWLIST,
- &k, &ksz, &n, &nsz))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&:new", KWLIST,
+ convbin, &k, convbin, &n))
- if (keysz(ksz, info->keysz) != ksz) VALERR("bad key length");
- if (nsz != info->noncesz) VALERR("bad nonce length");
+ if (keysz(k.sz, info->keysz) != k.sz) VALERR("bad key length");
+ if (n.sz != info->noncesz) VALERR("bad nonce length");
return (grand_dopywrap(ty,
return (grand_dopywrap(ty,
- ((gcnrand_func *)info->func)(k, ksz, n),
+ ((gcnrand_func *)info->func)(k.p, k.sz, n.p),
f_freeme));
end:
return (0);
f_freeme));
end:
return (0);
static const char
*const kwlist_shake[] = { "key", "func", "perso", 0 },
*const kwlist_func[] = { "key", "perso", 0 };
static const char
*const kwlist_shake[] = { "key", "func", "perso", 0 },
*const kwlist_func[] = { "key", "perso", 0 };
- char *k, *f = 0, *p = 0;
- Py_ssize_t ksz, fsz = 0, psz = 0;
+ struct bin k, f = { 0, 0 }, p = { 0, 0 };
if ((info->f&RNGF_MASK) == RNG_SHAKE
if ((info->f&RNGF_MASK) == RNG_SHAKE
- ? !PyArg_ParseTupleAndKeywords(arg, kw, "s#|s#s#:new",
+ ? !PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&O&:new",
(/*unconst*/ char **)kwlist_shake,
(/*unconst*/ char **)kwlist_shake,
- &k, &ksz, &f, &fsz, &p, &psz)
- : !PyArg_ParseTupleAndKeywords(arg, kw, "s#|s#:new",
+ convbin, &k,
+ convbin, &f, convbin, &p)
+ : !PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new",
(/*unconst*/ char **)kwlist_func,
(/*unconst*/ char **)kwlist_func,
+ convbin, &k, convbin, &p))
- if (keysz(ksz, info->keysz) != ksz) VALERR("bad key length");
+ if (keysz(k.sz, info->keysz) != k.sz) VALERR("bad key length");
return (grand_dopywrap(ty,
(info->f&RNGF_MASK) == RNG_SHAKE
return (grand_dopywrap(ty,
(info->f&RNGF_MASK) == RNG_SHAKE
- ? ((gcshakerand_func *)info->func)(f, fsz,
- p, psz,
- k, ksz)
- : ((gcshafuncrand_func *)info->func)(p, psz,
- k, ksz),
+ ? ((gcshakerand_func *)info->func)(f.p, f.sz,
+ p.p, p.sz,
+ k.p, k.sz)
+ : ((gcshafuncrand_func *)info->func)(p.p, p.sz,
+ k.p, k.sz),
f_freeme));
end:
return (0);
f_freeme));
end:
return (0);
static PyObject *sslprf_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
static PyObject *sslprf_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
- char *k, *s;
- Py_ssize_t ksz, ssz;
const gchash *hco = &md5, *hci = &sha;
PyObject *rc = 0;
static const char *const kwlist[] = { "key", "seed", "ohash", "ihash", 0 };
const gchash *hco = &md5, *hci = &sha;
PyObject *rc = 0;
static const char *const kwlist[] = { "key", "seed", "ohash", "ihash", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#s#|O&O&:new", KWLIST,
- &k, &ksz, &s, &ssz,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&|O&O&:new", KWLIST,
+ convbin, &k, convbin, &s,
convgchash, &hco, convgchash, &hci))
goto end;
convgchash, &hco, convgchash, &hci))
goto end;
- rc = grand_dopywrap(ty, sslprf_rand(hco, hci, k, ksz, s, ssz), f_freeme);
+ rc = grand_dopywrap(ty, sslprf_rand(hco, hci, k.p, k.sz, s.p, s.sz),
+ f_freeme);
end:
return (rc);
}
static PyObject *tlsdx_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
end:
return (rc);
}
static PyObject *tlsdx_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
- char *k, *s;
- Py_ssize_t ksz, ssz;
const gcmac *mc = &sha_hmac;
PyObject *rc = 0;
static const char *const kwlist[] = { "key", "seed", "mac", 0 };
const gcmac *mc = &sha_hmac;
PyObject *rc = 0;
static const char *const kwlist[] = { "key", "seed", "mac", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#s#|O&:new", KWLIST,
- &k, &ksz, &s, &ssz,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&|O&:new", KWLIST,
+ convbin, &k, convbin, &s,
convgcmac, &mc))
goto end;
convgcmac, &mc))
goto end;
- rc = grand_dopywrap(ty, tlsdx_rand(mc, k, ksz, s, ssz), f_freeme);
+ rc = grand_dopywrap(ty, tlsdx_rand(mc, k.p, k.sz, s.p, s.sz), f_freeme);
end:
return (rc);
}
static PyObject *tlsprf_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
end:
return (rc);
}
static PyObject *tlsprf_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
- char *k, *s;
- Py_ssize_t ksz, ssz;
const gcmac *mcl = &md5_hmac, *mcr = &sha_hmac;
PyObject *rc = 0;
static const char *const kwlist[] = { "key", "seed", "lmac", "rmac", 0 };
const gcmac *mcl = &md5_hmac, *mcr = &sha_hmac;
PyObject *rc = 0;
static const char *const kwlist[] = { "key", "seed", "lmac", "rmac", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#s#|O&O&:new", KWLIST,
- &k, &ksz, &s, &ssz,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&|O&O&:new", KWLIST,
+ convbin, &k, convbin, &s,
convgcmac, &mcl, convgcmac, &mcr))
goto end;
convgcmac, &mcl, convgcmac, &mcr))
goto end;
- rc = grand_dopywrap(ty, tlsprf_rand(mcl, mcr, k, ksz, s, ssz), f_freeme);
+ rc = grand_dopywrap(ty, tlsprf_rand(mcl, mcr, k.p, k.sz, s.p, s.sz),
+ f_freeme);
static PyObject *dsarand_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
static PyObject *dsarand_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
{
- char *p;
- Py_ssize_t sz;
PyObject *rc = 0;
static const char *const kwlist[] = { "seed", 0 };
PyObject *rc = 0;
static const char *const kwlist[] = { "seed", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", KWLIST, &p, &sz))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:new", KWLIST, convbin, &in))
- rc = grand_dopywrap(ty, dsarand_create(p, sz), f_freeme);
+ rc = grand_dopywrap(ty, dsarand_create(in.p, in.sz), f_freeme);
static PyObject *gfsharesplit_pynew(PyTypeObject *ty,
PyObject *arg, PyObject *kw)
{
static PyObject *gfsharesplit_pynew(PyTypeObject *ty,
PyObject *arg, PyObject *kw)
{
- char *p;
- Py_ssize_t n;
unsigned t;
grand *r = &rand_global;
gfshare_pyobj *s;
static const char *const kwlist[] = { "threshold", "secret", "rng", 0 };
unsigned t;
grand *r = &rand_global;
gfshare_pyobj *s;
static const char *const kwlist[] = { "threshold", "secret", "rng", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&s#|O&:new", KWLIST,
- convuint, &t, &p, &n, convgrand, &r))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&|O&:new", KWLIST,
+ convuint, &t, convbin, &in,
+ convgrand, &r))
goto end;
if (!t || t > 255) VALERR("threshold must be nonzero and < 256");
s = (gfshare_pyobj *)ty->tp_alloc(ty, 0);
goto end;
if (!t || t > 255) VALERR("threshold must be nonzero and < 256");
s = (gfshare_pyobj *)ty->tp_alloc(ty, 0);
- gfshare_create(&s->s, t, n);
- gfshare_mkshares(&s->s, r, p);
+ gfshare_create(&s->s, t, in.sz);
+ gfshare_mkshares(&s->s, r, in.p);
return ((PyObject *)s);
end:
return (0);
return ((PyObject *)s);
end:
return (0);
static PyObject *gfsmeth_add(PyObject *me, PyObject *arg)
{
unsigned i;
static PyObject *gfsmeth_add(PyObject *me, PyObject *arg)
{
unsigned i;
- char *p;
- Py_ssize_t n;
- if (!PyArg_ParseTuple(arg, "O&s#:add", convuint, &i, &p, &n)) goto end;
+ struct bin s;
+ if (!PyArg_ParseTuple(arg, "O&O&:add", convuint, &i, convbin, &s))
+ goto end;
if (i > 254) VALERR("index must be < 255");
if (i > 254) VALERR("index must be < 255");
- if (n != GFSHARE_S(me)->sz) VALERR("bad share size");
+ if (s.sz != GFSHARE_S(me)->sz) VALERR("bad share size");
if (gfshare_addedp(GFSHARE_S(me), i)) VALERR("this share already added");
if (GFSHARE_S(me)->i >= GFSHARE_S(me)->t) VALERR("enough shares already");
if (gfshare_addedp(GFSHARE_S(me), i)) VALERR("this share already added");
if (GFSHARE_S(me)->i >= GFSHARE_S(me)->t) VALERR("enough shares already");
- gfshare_add(GFSHARE_S(me), i, p);
+ gfshare_add(GFSHARE_S(me), i, s.p);
return (PyInt_FromLong(GFSHARE_S(me)->t - GFSHARE_S(me)->i));
end:
return (0);
return (PyInt_FromLong(GFSHARE_S(me)->t - GFSHARE_S(me)->i));
end:
return (0);
buf.zero(17)
buf.put(T.span(23))
me.assertEqual(buf.size, 40)
buf.zero(17)
buf.put(T.span(23))
me.assertEqual(buf.size, 40)
+ me.assertEqual(buf, C.ByteString.zero(17) + T.span(23))
me.assertEqual(buf.contents, C.ByteString.zero(17) + T.span(23))
###----- That's all, folks --------------------------------------------------
me.assertEqual(buf.contents, C.ByteString.zero(17) + T.span(23))
###----- That's all, folks --------------------------------------------------