[catacomb-python] / share.c

/* -*-c-*-
 *
 * $Id$
 *
 * Secret sharing
 *
 * (c) 2005 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of the Python interface to Catacomb.
 *
 * Catacomb/Python is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * Catacomb/Python is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with Catacomb/Python; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#include "catacomb-python.h"

/*----- GF(2^8)-based secret-sharing --------------------------------------*/

typedef struct gfshare_pyobj {
  PyObject_HEAD
  gfshare s;
} gfshare_pyobj;

static PyTypeObject
  *gfshare_pytype, *gfsharesplit_pytype, *gfsharejoin_pytype;
#define GFSHARE_PYCHECK(o) PyObject_TypeCheck((o), gfshare_pytype)
#define GFSHARESPLIT_PYCHECK(o) PyObject_TypeCheck((o), gfsharesplit_pytype)
#define GFSHAREJOIN_PYCHECK(o) PyObject_TypeCheck((o), gfsharejoin_pytype)
#define GFSHARE_S(o) (&((gfshare_pyobj *)(o))->s)

static void gfshare_pydealloc(PyObject *me)
{
  gfshare_destroy(GFSHARE_S(me));
  FREEOBJ(me);
}

static PyObject *gfsget_threshold(PyObject *me, void *hunoz)
  { return (PyInt_FromLong(GFSHARE_S(me)->t)); }
static PyObject *gfsget_size(PyObject *me, void *hunoz)
  { return (PyInt_FromLong(GFSHARE_S(me)->sz)); }

static PyGetSetDef gfshare_pygetset[]= {
#define GETSETNAME(op, name) gfs##op##_##name
  GET	(threshold,	"S.threshold -> THRESHOLD")
  GET	(size,		"S.size -> SECRETSZ")
#undef GETSETNAME
  { 0 }
};

static PyTypeObject gfshare_pytype_skel = {
  PyObject_HEAD_INIT(&PyType_Type) 0,	/* Header */
  "catacomb.GFShare",			/* @tp_name@ */
  sizeof(gfshare_pyobj),		/* @tp_basicsize@ */
  0,					/* @tp_itemsize@ */

  gfshare_pydealloc,			/* @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@ */
"Binary-field secret sharing base class.",

  0,					/* @tp_traverse@ */
  0,					/* @tp_clear@ */
  0,					/* @tp_richcompare@ */
  0,					/* @tp_weaklistoffset@ */
  0,					/* @tp_iter@ */
  0,					/* @tp_iternexr@ */
  0,					/* @tp_methods@ */
  0,					/* @tp_members@ */
  gfshare_pygetset,			/* @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 PyObject *gfsharesplit_pynew(PyTypeObject *ty,
				    PyObject *arg, PyObject *kw)
{
  char *p;
  int n;
  unsigned t;
  grand *r = &rand_global;
  gfshare_pyobj *s;
  char *kwlist[] = { "threshold", "secret", "rng", 0 };
  if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&s#|O&:new", kwlist,
				   convuint, &t, &p, &n, convgrand, &r))
    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);
  return ((PyObject *)s);
end:
  return (0);
}

static PyObject *gfsmeth_get(PyObject *me, PyObject *arg)
{
  unsigned i;
  PyObject *rc = 0;
  if (!PyArg_ParseTuple(arg, "O&:get", convuint, &i)) goto end;
  if (i >= 255) VALERR("index must be < 255");
  rc = bytestring_pywrap(0, GFSHARE_S(me)->sz);
  gfshare_get(GFSHARE_S(me), i, PyString_AS_STRING(rc));
end:
  return (rc);
}

static PyMethodDef gfsharesplit_pymethods[] = {
#define METHNAME(name) gfsmeth_##name
  METH	(get,		"S.get(I) -> SHARE")
#undef METHNAME
  { 0 }
};

static PyTypeObject gfsharesplit_pytype_skel = {
  PyObject_HEAD_INIT(&PyType_Type) 0,	/* Header */
  "catacomb.GFShareSplit",		/* @tp_name@ */
  sizeof(gfshare_pyobj),		/* @tp_basicsize@ */
  0,					/* @tp_itemsize@ */

  gfshare_pydealloc,			/* @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@ */
"Binary field secret sharing: split secret into shares.",

  0,					/* @tp_traverse@ */
  0,					/* @tp_clear@ */
  0,					/* @tp_richcompare@ */
  0,					/* @tp_weaklistoffset@ */
  0,					/* @tp_iter@ */
  0,					/* @tp_iternexr@ */
  gfsharesplit_pymethods,		/* @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@ */
  gfsharesplit_pynew,			/* @tp_new@ */
  0,					/* @tp_free@ */
  0					/* @tp_is_gc@ */
};

static PyObject *gfsharejoin_pynew(PyTypeObject *ty,
				   PyObject *arg, PyObject *kw)
{
  unsigned t, sz;
  gfshare_pyobj *s;
  char *kwlist[] = { "threshold", "size", 0 };
  if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&:new", kwlist,
				   convuint, &t, convuint, &sz))
    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, sz);
  return ((PyObject *)s);
end:
  return (0);
}

static PyObject *gfsmeth_addedp(PyObject *me, PyObject *arg)
{
  unsigned i;
  if (!PyArg_ParseTuple(arg, "O&:addedp", convuint, &i)) goto end;
  if (i > 254) VALERR("index must be < 255");
  return (getbool(gfshare_addedp(GFSHARE_S(me), i)));
end:
  return (0);
}

static PyObject *gfsmeth_add(PyObject *me, PyObject *arg)
{
  unsigned i;
  char *p;
  int n;
  if (!PyArg_ParseTuple(arg, "O&s#:add", convuint, &i, &p, &n)) goto end;
  if (i > 254) VALERR("index must be < 255");
  if (n != 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");
  gfshare_add(GFSHARE_S(me), i, p);
  return (PyInt_FromLong(GFSHARE_S(me)->t - GFSHARE_S(me)->i));
end:
  return (0);
}

static PyObject *gfsmeth_combine(PyObject *me, PyObject *arg)
{
  PyObject *rc = 0;
  if (!PyArg_ParseTuple(arg, ":combine")) goto end;
  if (GFSHARE_S(me)->i < GFSHARE_S(me)->t) VALERR("not enough shares yet");
  rc = bytestring_pywrap(0, GFSHARE_S(me)->sz);
  gfshare_combine(GFSHARE_S(me), PyString_AS_STRING(rc));
end:
  return (rc);
}

static PyMethodDef gfsharejoin_pymethods[] = {
#define METHNAME(name) gfsmeth_##name
  METH	(addedp,	"S.addedp(I) -> BOOL")
  METH	(add,		"S.add(I, SHARE) -> REMAIN")
  METH	(combine,	"S.combine() -> SECRET")
#undef METHNAME
  { 0 }
};

static PyObject *gfsget_remain(PyObject *me, void *hunoz)
  { return (PyInt_FromLong(GFSHARE_S(me)->t - GFSHARE_S(me)->i)); }

static PyGetSetDef gfsharejoin_pygetset[]= {
#define GETSETNAME(op, name) gfs##op##_##name
  GET	(remain,	"S.remain -> REMAIN")
#undef GETSETNAME
  { 0 }
};

static PyTypeObject gfsharejoin_pytype_skel = {
  PyObject_HEAD_INIT(&PyType_Type) 0,	/* Header */
  "catacomb.GFShareJoin",		/* @tp_name@ */
  sizeof(gfshare_pyobj),		/* @tp_basicsize@ */
  0,					/* @tp_itemsize@ */

  gfshare_pydealloc,			/* @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@ */
"Binary field secret sharing: join shares to recover secret.",

  0,					/* @tp_traverse@ */
  0,					/* @tp_clear@ */
  0,					/* @tp_richcompare@ */
  0,					/* @tp_weaklistoffset@ */
  0,					/* @tp_iter@ */
  0,					/* @tp_iternexr@ */
  gfsharejoin_pymethods,		/* @tp_methods@ */
  0,					/* @tp_members@ */
  gfsharejoin_pygetset,			/* @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@ */
  gfsharejoin_pynew,			/* @tp_new@ */
  0,					/* @tp_free@ */
  0					/* @tp_is_gc@ */
};

/*----- Prime-field secret-sharing ----------------------------------------*/

typedef struct share_pyobj {
  PyObject_HEAD
  share s;
} share_pyobj;

static PyTypeObject
  *share_pytype, *sharesplit_pytype, *sharejoin_pytype;
#define SHARE_PYCHECK(o) PyObject_TypeCheck((o), share_pytype)
#define SHARESPLIT_PYCHECK(o) PyObject_TypeCheck((o), sharesplit_pytype)
#define SHAREJOIN_PYCHECK(o) PyObject_TypeCheck((o), sharejoin_pytype)
#define SHARE_S(o) (&((share_pyobj *)(o))->s)

static void share_pydealloc(PyObject *me)
{
  share_destroy(SHARE_S(me));
  FREEOBJ(me);
}

static PyObject *sget_threshold(PyObject *me, void *hunoz)
  { return (PyInt_FromLong(SHARE_S(me)->t)); }
static PyObject *sget_modulus(PyObject *me, void *hunoz)
  { return (mp_pywrap(SHARE_S(me)->p)); }

static PyGetSetDef share_pygetset[]= {
#define GETSETNAME(op, name) s##op##_##name
  GET	(threshold,	"S.threshold -> THRESHOLD")
  GET	(modulus,	"S.modulus -> MODULUS")
#undef GETSETNAME
  { 0 }
};

static PyTypeObject share_pytype_skel = {
  PyObject_HEAD_INIT(&PyType_Type) 0,	/* Header */
  "catacomb.Share",			/* @tp_name@ */
  sizeof(share_pyobj),			/* @tp_basicsize@ */
  0,					/* @tp_itemsize@ */

  share_pydealloc,			/* @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@ */
"Prime-field secret sharing base class.",

  0,					/* @tp_traverse@ */
  0,					/* @tp_clear@ */
  0,					/* @tp_richcompare@ */
  0,					/* @tp_weaklistoffset@ */
  0,					/* @tp_iter@ */
  0,					/* @tp_iternexr@ */
  0,					/* @tp_methods@ */
  0,					/* @tp_members@ */
  share_pygetset,			/* @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 PyObject *sharesplit_pynew(PyTypeObject *ty,
				  PyObject *arg, PyObject *kw)
{
  mp *sec = 0;
  unsigned t;
  grand *r = &rand_global;
  mp *m = 0;
  share_pyobj *s;
  char *kwlist[] = { "threshold", "secret", "modulus", "rng", 0 };
  if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&)&|O&O&:new", kwlist,
				   convuint, &t, convmp, &sec,
				   convmp, &m, convgrand, &r))
    goto end;
  if (!t) VALERR("threshold must be nonzero");
  s = (share_pyobj *)ty->tp_alloc(ty, 0);
  share_create(&s->s, t);
  s->s.p = m;
  share_mkshares(&s->s, r, sec);
  mp_drop(sec);
  return ((PyObject *)s);
end:
  mp_drop(m);
  mp_drop(sec);
  return (0);
}

static PyObject *smeth_get(PyObject *me, PyObject *arg)
{
  unsigned i;
  PyObject *rc = 0;
  if (!PyArg_ParseTuple(arg, "O&:get", convuint, &i)) goto end;
  rc = mp_pywrap(share_get(SHARE_S(me), MP_NEW, i));
end:
  return (rc);
}

static PyMethodDef sharesplit_pymethods[] = {
#define METHNAME(name) smeth_##name
  METH	(get,		"S.get(I) -> SHARE")
#undef METHNAME
  { 0 }
};

static PyTypeObject sharesplit_pytype_skel = {
  PyObject_HEAD_INIT(&PyType_Type) 0,	/* Header */
  "catacomb.ShareSplit",		/* @tp_name@ */
  sizeof(share_pyobj),			/* @tp_basicsize@ */
  0,					/* @tp_itemsize@ */

  share_pydealloc,			/* @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@ */
"Prime field secret sharing: split secret into shares.",

  0,					/* @tp_traverse@ */
  0,					/* @tp_clear@ */
  0,					/* @tp_richcompare@ */
  0,					/* @tp_weaklistoffset@ */
  0,					/* @tp_iter@ */
  0,					/* @tp_iternexr@ */
  sharesplit_pymethods,			/* @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@ */
  sharesplit_pynew,			/* @tp_new@ */
  0,					/* @tp_free@ */
  0					/* @tp_is_gc@ */
};

static PyObject *sharejoin_pynew(PyTypeObject *ty,
				 PyObject *arg, PyObject *kw)
{
  unsigned t;
  mp *m = 0;
  share_pyobj *s;
  char *kwlist[] = { "threshold", "modulus", 0 };
  if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&:new", kwlist,
				   convuint, &t, convmp, &m))
    goto end;
  if (!t) VALERR("threshold must be nonzero");
  s = (share_pyobj *)ty->tp_alloc(ty, 0);
  share_create(&s->s, t);
  s->s.p = m;
  return ((PyObject *)s);
end:
  mp_drop(m);
  return (0);
}

static PyObject *smeth_addedp(PyObject *me, PyObject *arg)
{
  unsigned i;
  if (!PyArg_ParseTuple(arg, "O&:addedp", convuint, &i)) goto end;
  return (getbool(share_addedp(SHARE_S(me), i)));
end:
  return (0);
}

static PyObject *smeth_add(PyObject *me, PyObject *arg)
{
  unsigned i;
  mp *s = 0;
  PyObject *rc = 0;
  if (!PyArg_ParseTuple(arg, "O&O&:add", convuint, &i, convmp, &s)) goto end;
  if (MP_NEGP(s) || MP_CMP(s, >=, SHARE_S(me)->p))
    VALERR("share out of range");
  if (share_addedp(SHARE_S(me), i)) VALERR("this share already added");
  if (SHARE_S(me)->i >= SHARE_S(me)->t) VALERR("enough shares already");
  share_add(SHARE_S(me), i, s);
  rc = PyInt_FromLong(SHARE_S(me)->t - SHARE_S(me)->i);
end:
  mp_drop(s);
  return (rc);
}

static PyObject *smeth_combine(PyObject *me, PyObject *arg)
{
  PyObject *rc = 0;
  if (!PyArg_ParseTuple(arg, ":combine")) goto end;
  if (SHARE_S(me)->i < SHARE_S(me)->t) VALERR("not enough shares yet");
  rc = mp_pywrap(share_combine(SHARE_S(me)));
end:
  return (rc);
}

static PyMethodDef sharejoin_pymethods[] = {
#define METHNAME(name) smeth_##name
  METH	(addedp,	"S.addedp(I) -> BOOL")
  METH	(add,		"S.add(I, SHARE) -> REMAIN")
  METH	(combine,	"S.combine() -> SECRET")
#undef METHNAME
  { 0 }
};

static PyObject *sget_remain(PyObject *me, void *hunoz)
  { return (PyInt_FromLong(SHARE_S(me)->t - SHARE_S(me)->i)); }

static PyGetSetDef sharejoin_pygetset[]= {
#define GETSETNAME(op, name) s##op##_##name
  GET	(remain,	"S.remain -> REMAIN")
#undef GETSETNAME
  { 0 }
};

static PyTypeObject sharejoin_pytype_skel = {
  PyObject_HEAD_INIT(&PyType_Type) 0,	/* Header */
  "catacomb.ShareJoin",			/* @tp_name@ */
  sizeof(share_pyobj),			/* @tp_basicsize@ */
  0,					/* @tp_itemsize@ */

  share_pydealloc,			/* @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@ */
"Prime field secret sharing: join shares to recover secret.",

  0,					/* @tp_traverse@ */
  0,					/* @tp_clear@ */
  0,					/* @tp_richcompare@ */
  0,					/* @tp_weaklistoffset@ */
  0,					/* @tp_iter@ */
  0,					/* @tp_iternexr@ */
  sharejoin_pymethods,			/* @tp_methods@ */
  0,					/* @tp_members@ */
  sharejoin_pygetset,			/* @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@ */
  sharejoin_pynew,			/* @tp_new@ */
  0,					/* @tp_free@ */
  0					/* @tp_is_gc@ */
};

/*----- Global stuff ------------------------------------------------------*/

void share_pyinit(void)
{
  INITTYPE(gfshare, root);
  INITTYPE(gfsharesplit, gfshare);
  INITTYPE(gfsharejoin, gfshare);
  INITTYPE(share, root);
  INITTYPE(sharesplit, share);
  INITTYPE(sharejoin, share);
}

void share_pyinsert(PyObject *mod)
{
  INSERT("GFShare", gfshare_pytype);
  INSERT("GFShareSplit", gfsharesplit_pytype);
  INSERT("GFShareJoin", gfsharejoin_pytype);
  INSERT("Share", share_pytype);
  INSERT("ShareSplit", sharesplit_pytype);
  INSERT("ShareJoin", sharejoin_pytype);
}

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
46e6ad89	1	/* --c--
	2	*
	3	* $Id$
	4	*
	5	* Secret sharing
	6	*
	7	* (c) 2005 Straylight/Edgeware
	8	*/
	9
	10	/----- Licensing notice --------------------------------------------------
	11	*
	12	* This file is part of the Python interface to Catacomb.
	13	*
	14	* Catacomb/Python is free software; you can redistribute it and/or modify
	15	* it under the terms of the GNU General Public License as published by
	16	* the Free Software Foundation; either version 2 of the License, or
	17	* (at your option) any later version.
	18	*
	19	* Catacomb/Python is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU General Public License for more details.
	23	*
	24	* You should have received a copy of the GNU General Public License
	25	* along with Catacomb/Python; if not, write to the Free Software Foundation,
	26	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	27	*/
	28
	29	/----- Header files ------------------------------------------------------/
	30
	31	#include "catacomb-python.h"
	32
	33	/----- GF(2^8)-based secret-sharing --------------------------------------/
	34
	35	typedef struct gfshare_pyobj {
	36	PyObject_HEAD
	37	gfshare s;
	38	} gfshare_pyobj;
	39
	40	static PyTypeObject
	41	gfshare_pytype, gfsharesplit_pytype, *gfsharejoin_pytype;
	42	#define GFSHARE_PYCHECK(o) PyObject_TypeCheck((o), gfshare_pytype)
	43	#define GFSHARESPLIT_PYCHECK(o) PyObject_TypeCheck((o), gfsharesplit_pytype)
	44	#define GFSHAREJOIN_PYCHECK(o) PyObject_TypeCheck((o), gfsharejoin_pytype)
	45	#define GFSHARE_S(o) (&((gfshare_pyobj *)(o))->s)
	46
	47	static void gfshare_pydealloc(PyObject *me)
	48	{
	49	gfshare_destroy(GFSHARE_S(me));
	50	FREEOBJ(me);
	51	}
	52
	53	static PyObject gfsget_threshold(PyObject me, void *hunoz)
	54	{ return (PyInt_FromLong(GFSHARE_S(me)->t)); }
	55	static PyObject gfsget_size(PyObject me, void *hunoz)
	56	{ return (PyInt_FromLong(GFSHARE_S(me)->sz)); }
	57
	58	static PyGetSetDef gfshare_pygetset[]= {
	59	#define GETSETNAME(op, name) gfs##op##_##name
	60	GET (threshold, "S.threshold -> THRESHOLD")
	61	GET (size, "S.size -> SECRETSZ")
	62	#undef GETSETNAME
	63	{ 0 }
	64	};
65
66	static PyTypeObject gfshare_pytype_skel = {
67	PyObject_HEAD_INIT(&PyType_Type) 0, /* Header */
68	"catacomb.GFShare", /* @tp_name@ */
69	sizeof(gfshare_pyobj), /* @tp_basicsize@ */
70	0, /* @tp_itemsize@ */
71
72	gfshare_pydealloc, /* @tp_dealloc@ */
73	0, /* @tp_print@ */
74	0, /* @tp_getattr@ */
75	0, /* @tp_setattr@ */
76	0, /* @tp_compare@ */
77	0, /* @tp_repr@ */
78	0, /* @tp_as_number@ */
79	0, /* @tp_as_sequence@ */
80	0, /* @tp_as_mapping@ */
81	0, /* @tp_hash@ */
82	0, /* @tp_call@ */
83	0, /* @tp_str@ */
84	0, /* @tp_getattro@ */
85	0, /* @tp_setattro@ */
86	0, /* @tp_as_buffer@ */
87	Py_TPFLAGS_DEFAULT \| /* @tp_flags@ */
88	Py_TPFLAGS_BASETYPE,
89
90	/* @tp_doc@ */
91	"Binary-field secret sharing base class.",
92
93	0, /* @tp_traverse@ */
94	0, /* @tp_clear@ */
95	0, /* @tp_richcompare@ */
96	0, /* @tp_weaklistoffset@ */
97	0, /* @tp_iter@ */
98	0, /* @tp_iternexr@ */
99	0, /* @tp_methods@ */
100	0, /* @tp_members@ */
101	gfshare_pygetset, /* @tp_getset@ */
102	0, /* @tp_base@ */
103	0, /* @tp_dict@ */
104	0, /* @tp_descr_get@ */
105	0, /* @tp_descr_set@ */
106	0, /* @tp_dictoffset@ */
107	0, /* @tp_init@ */
108	PyType_GenericAlloc, /* @tp_alloc@ */
109	abstract_pynew, /* @tp_new@ */
110	0, /* @tp_free@ */
111	0 /* @tp_is_gc@ */
112	};
113
114	static PyObject gfsharesplit_pynew(PyTypeObject ty,
115	PyObject arg, PyObject kw)
116	{
117	char *p;
118	int n;
119	unsigned t;
120	grand *r = &rand_global;
121	gfshare_pyobj *s;
122	char *kwlist[] = { "threshold", "secret", "rng", 0 };
123	if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&s#\|O&:new", kwlist,
124	convuint, &t, &p, &n, convgrand, &r))
125	goto end;
126	if (!t \|\| t > 255) VALERR("threshold must be nonzero and < 256");
127	s = (gfshare_pyobj *)ty->tp_alloc(ty, 0);
128	gfshare_create(&s->s, t, n);
129	gfshare_mkshares(&s->s, r, p);
130	return ((PyObject *)s);
131	end:
132	return (0);
133	}
134
135	static PyObject gfsmeth_get(PyObject me, PyObject *arg)
136	{
137	unsigned i;
138	PyObject *rc = 0;
139	if (!PyArg_ParseTuple(arg, "O&:get", convuint, &i)) goto end;
140	if (i >= 255) VALERR("index must be < 255");
141	rc = bytestring_pywrap(0, GFSHARE_S(me)->sz);
142	gfshare_get(GFSHARE_S(me), i, PyString_AS_STRING(rc));
143	end:
144	return (rc);
145	}
146
147	static PyMethodDef gfsharesplit_pymethods[] = {
148	#define METHNAME(name) gfsmeth_##name
149	METH (get, "S.get(I) -> SHARE")
150	#undef METHNAME
151	{ 0 }
152	};
153
154	static PyTypeObject gfsharesplit_pytype_skel = {
155	PyObject_HEAD_INIT(&PyType_Type) 0, /* Header */
156	"catacomb.GFShareSplit", /* @tp_name@ */
157	sizeof(gfshare_pyobj), /* @tp_basicsize@ */
158	0, /* @tp_itemsize@ */
159
160	gfshare_pydealloc, /* @tp_dealloc@ */
161	0, /* @tp_print@ */
162	0, /* @tp_getattr@ */
163	0, /* @tp_setattr@ */
164	0, /* @tp_compare@ */
165	0, /* @tp_repr@ */
166	0, /* @tp_as_number@ */
167	0, /* @tp_as_sequence@ */
168	0, /* @tp_as_mapping@ */
169	0, /* @tp_hash@ */
170	0, /* @tp_call@ */
171	0, /* @tp_str@ */
172	0, /* @tp_getattro@ */
173	0, /* @tp_setattro@ */
174	0, /* @tp_as_buffer@ */
175	Py_TPFLAGS_DEFAULT \| /* @tp_flags@ */
176	Py_TPFLAGS_BASETYPE,
177
178	/* @tp_doc@ */
179	"Binary field secret sharing: split secret into shares.",
180
181	0, /* @tp_traverse@ */
182	0, /* @tp_clear@ */
183	0, /* @tp_richcompare@ */
184	0, /* @tp_weaklistoffset@ */
185	0, /* @tp_iter@ */
186	0, /* @tp_iternexr@ */
187	gfsharesplit_pymethods, /* @tp_methods@ */
188	0, /* @tp_members@ */
189	0, /* @tp_getset@ */
190	0, /* @tp_base@ */
191	0, /* @tp_dict@ */
192	0, /* @tp_descr_get@ */
193	0, /* @tp_descr_set@ */
194	0, /* @tp_dictoffset@ */
195	0, /* @tp_init@ */
196	PyType_GenericAlloc, /* @tp_alloc@ */
197	gfsharesplit_pynew, /* @tp_new@ */
198	0, /* @tp_free@ */
199	0 /* @tp_is_gc@ */
200	};
201
202	static PyObject gfsharejoin_pynew(PyTypeObject ty,
203	PyObject arg, PyObject kw)
204	{
205	unsigned t, sz;
206	gfshare_pyobj *s;
207	char *kwlist[] = { "threshold", "size", 0 };
208	if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&:new", kwlist,
209	convuint, &t, convuint, &sz))
210	goto end;
211	if (!t \|\| t > 255) VALERR("threshold must be nonzero and < 256");
212	s = (gfshare_pyobj *)ty->tp_alloc(ty, 0);
213	gfshare_create(&s->s, t, sz);
214	return ((PyObject *)s);
215	end:
216	return (0);
217	}
218
219	static PyObject gfsmeth_addedp(PyObject me, PyObject *arg)
220	{
221	unsigned i;
222	if (!PyArg_ParseTuple(arg, "O&:addedp", convuint, &i)) goto end;
223	if (i > 254) VALERR("index must be < 255");
224	return (getbool(gfshare_addedp(GFSHARE_S(me), i)));
225	end:
226	return (0);
227	}
228
229	static PyObject gfsmeth_add(PyObject me, PyObject *arg)
230	{
231	unsigned i;
232	char *p;
233	int n;
234	if (!PyArg_ParseTuple(arg, "O&s#:add", convuint, &i, &p, &n)) goto end;
235	if (i > 254) VALERR("index must be < 255");
236	if (n != GFSHARE_S(me)->sz) VALERR("bad share size");
237	if (gfshare_addedp(GFSHARE_S(me), i)) VALERR("this share already added");
238	if (GFSHARE_S(me)->i >= GFSHARE_S(me)->t) VALERR("enough shares already");
239	gfshare_add(GFSHARE_S(me), i, p);
240	return (PyInt_FromLong(GFSHARE_S(me)->t - GFSHARE_S(me)->i));
241	end:
242	return (0);
243	}
244
245	static PyObject gfsmeth_combine(PyObject me, PyObject *arg)
246	{
247	PyObject *rc = 0;
248	if (!PyArg_ParseTuple(arg, ":combine")) goto end;
249	if (GFSHARE_S(me)->i < GFSHARE_S(me)->t) VALERR("not enough shares yet");
250	rc = bytestring_pywrap(0, GFSHARE_S(me)->sz);
251	gfshare_combine(GFSHARE_S(me), PyString_AS_STRING(rc));
252	end:
253	return (rc);
254	}
255
256	static PyMethodDef gfsharejoin_pymethods[] = {
257	#define METHNAME(name) gfsmeth_##name
258	METH (addedp, "S.addedp(I) -> BOOL")
259	METH (add, "S.add(I, SHARE) -> REMAIN")
260	METH (combine, "S.combine() -> SECRET")
261	#undef METHNAME
262	{ 0 }
263	};
264
265	static PyObject gfsget_remain(PyObject me, void *hunoz)
266	{ return (PyInt_FromLong(GFSHARE_S(me)->t - GFSHARE_S(me)->i)); }
267
268	static PyGetSetDef gfsharejoin_pygetset[]= {
269	#define GETSETNAME(op, name) gfs##op##_##name
270	GET (remain, "S.remain -> REMAIN")
271	#undef GETSETNAME
272	{ 0 }
273	};
274
275	static PyTypeObject gfsharejoin_pytype_skel = {
276	PyObject_HEAD_INIT(&PyType_Type) 0, /* Header */
277	"catacomb.GFShareJoin", /* @tp_name@ */
278	sizeof(gfshare_pyobj), /* @tp_basicsize@ */
279	0, /* @tp_itemsize@ */
280
281	gfshare_pydealloc, /* @tp_dealloc@ */
282	0, /* @tp_print@ */
283	0, /* @tp_getattr@ */
284	0, /* @tp_setattr@ */
285	0, /* @tp_compare@ */
286	0, /* @tp_repr@ */
287	0, /* @tp_as_number@ */
288	0, /* @tp_as_sequence@ */
289	0, /* @tp_as_mapping@ */
290	0, /* @tp_hash@ */
291	0, /* @tp_call@ */
292	0, /* @tp_str@ */
293	0, /* @tp_getattro@ */
294	0, /* @tp_setattro@ */
295	0, /* @tp_as_buffer@ */
296	Py_TPFLAGS_DEFAULT \| /* @tp_flags@ */
297	Py_TPFLAGS_BASETYPE,
298
299	/* @tp_doc@ */
300	"Binary field secret sharing: join shares to recover secret.",
301
302	0, /* @tp_traverse@ */
303	0, /* @tp_clear@ */
304	0, /* @tp_richcompare@ */
305	0, /* @tp_weaklistoffset@ */
306	0, /* @tp_iter@ */
307	0, /* @tp_iternexr@ */
308	gfsharejoin_pymethods, /* @tp_methods@ */
309	0, /* @tp_members@ */
310	gfsharejoin_pygetset, /* @tp_getset@ */
311	0, /* @tp_base@ */
312	0, /* @tp_dict@ */
313	0, /* @tp_descr_get@ */
314	0, /* @tp_descr_set@ */
315	0, /* @tp_dictoffset@ */
316	0, /* @tp_init@ */
317	PyType_GenericAlloc, /* @tp_alloc@ */
318	gfsharejoin_pynew, /* @tp_new@ */
319	0, /* @tp_free@ */
320	0 /* @tp_is_gc@ */
321	};
322
323	/----- Prime-field secret-sharing ----------------------------------------/
324
325	typedef struct share_pyobj {
326	PyObject_HEAD
327	share s;
328	} share_pyobj;
329
330	static PyTypeObject
331	share_pytype, sharesplit_pytype, *sharejoin_pytype;
332	#define SHARE_PYCHECK(o) PyObject_TypeCheck((o), share_pytype)
333	#define SHARESPLIT_PYCHECK(o) PyObject_TypeCheck((o), sharesplit_pytype)
334	#define SHAREJOIN_PYCHECK(o) PyObject_TypeCheck((o), sharejoin_pytype)
335	#define SHARE_S(o) (&((share_pyobj *)(o))->s)
336
337	static void share_pydealloc(PyObject *me)
338	{
339	share_destroy(SHARE_S(me));
340	FREEOBJ(me);
341	}
342
343	static PyObject sget_threshold(PyObject me, void *hunoz)
344	{ return (PyInt_FromLong(SHARE_S(me)->t)); }
345	static PyObject sget_modulus(PyObject me, void *hunoz)
346	{ return (mp_pywrap(SHARE_S(me)->p)); }
347
348	static PyGetSetDef share_pygetset[]= {
349	#define GETSETNAME(op, name) s##op##_##name
350	GET (threshold, "S.threshold -> THRESHOLD")
351	GET (modulus, "S.modulus -> MODULUS")
352	#undef GETSETNAME
353	{ 0 }
354	};
355
356	static PyTypeObject share_pytype_skel = {
357	PyObject_HEAD_INIT(&PyType_Type) 0, /* Header */
358	"catacomb.Share", /* @tp_name@ */
359	sizeof(share_pyobj), /* @tp_basicsize@ */
360	0, /* @tp_itemsize@ */
361
362	share_pydealloc, /* @tp_dealloc@ */
363	0, /* @tp_print@ */
364	0, /* @tp_getattr@ */
365	0, /* @tp_setattr@ */
366	0, /* @tp_compare@ */
367	0, /* @tp_repr@ */
368	0, /* @tp_as_number@ */
369	0, /* @tp_as_sequence@ */
370	0, /* @tp_as_mapping@ */
371	0, /* @tp_hash@ */
372	0, /* @tp_call@ */
373	0, /* @tp_str@ */
374	0, /* @tp_getattro@ */
375	0, /* @tp_setattro@ */
376	0, /* @tp_as_buffer@ */
377	Py_TPFLAGS_DEFAULT \| /* @tp_flags@ */
378	Py_TPFLAGS_BASETYPE,
379
380	/* @tp_doc@ */
381	"Prime-field secret sharing base class.",
382
383	0, /* @tp_traverse@ */
384	0, /* @tp_clear@ */
385	0, /* @tp_richcompare@ */
386	0, /* @tp_weaklistoffset@ */
387	0, /* @tp_iter@ */
388	0, /* @tp_iternexr@ */
389	0, /* @tp_methods@ */
390	0, /* @tp_members@ */
391	share_pygetset, /* @tp_getset@ */
392	0, /* @tp_base@ */
393	0, /* @tp_dict@ */
394	0, /* @tp_descr_get@ */
395	0, /* @tp_descr_set@ */
396	0, /* @tp_dictoffset@ */
397	0, /* @tp_init@ */
398	PyType_GenericAlloc, /* @tp_alloc@ */
399	abstract_pynew, /* @tp_new@ */
400	0, /* @tp_free@ */
401	0 /* @tp_is_gc@ */
402	};
403
404	static PyObject sharesplit_pynew(PyTypeObject ty,
405	PyObject arg, PyObject kw)
406	{
407	mp *sec = 0;
408	unsigned t;
409	grand *r = &rand_global;
410	mp *m = 0;
411	share_pyobj *s;
412	char *kwlist[] = { "threshold", "secret", "modulus", "rng", 0 };
413	if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&)&\|O&O&:new", kwlist,
414	convuint, &t, convmp, &sec,
415	convmp, &m, convgrand, &r))
416	goto end;
417	if (!t) VALERR("threshold must be nonzero");
418	s = (share_pyobj *)ty->tp_alloc(ty, 0);
419	share_create(&s->s, t);
420	s->s.p = m;
421	share_mkshares(&s->s, r, sec);
422	mp_drop(sec);
423	return ((PyObject *)s);
424	end:
425	mp_drop(m);
426	mp_drop(sec);
427	return (0);
428	}
429
430	static PyObject smeth_get(PyObject me, PyObject *arg)
431	{
432	unsigned i;
433	PyObject *rc = 0;
434	if (!PyArg_ParseTuple(arg, "O&:get", convuint, &i)) goto end;
435	rc = mp_pywrap(share_get(SHARE_S(me), MP_NEW, i));
436	end:
437	return (rc);
438	}
439
440	static PyMethodDef sharesplit_pymethods[] = {
441	#define METHNAME(name) smeth_##name
442	METH (get, "S.get(I) -> SHARE")
443	#undef METHNAME
444	{ 0 }
445	};
446
447	static PyTypeObject sharesplit_pytype_skel = {
448	PyObject_HEAD_INIT(&PyType_Type) 0, /* Header */
449	"catacomb.ShareSplit", /* @tp_name@ */
450	sizeof(share_pyobj), /* @tp_basicsize@ */
451	0, /* @tp_itemsize@ */
452
453	share_pydealloc, /* @tp_dealloc@ */
454	0, /* @tp_print@ */
455	0, /* @tp_getattr@ */
456	0, /* @tp_setattr@ */
457	0, /* @tp_compare@ */
458	0, /* @tp_repr@ */
459	0, /* @tp_as_number@ */
460	0, /* @tp_as_sequence@ */
461	0, /* @tp_as_mapping@ */
462	0, /* @tp_hash@ */
463	0, /* @tp_call@ */
464	0, /* @tp_str@ */
465	0, /* @tp_getattro@ */
466	0, /* @tp_setattro@ */
467	0, /* @tp_as_buffer@ */
468	Py_TPFLAGS_DEFAULT \| /* @tp_flags@ */
469	Py_TPFLAGS_BASETYPE,
470
471	/* @tp_doc@ */
472	"Prime field secret sharing: split secret into shares.",
473
474	0, /* @tp_traverse@ */
475	0, /* @tp_clear@ */
476	0, /* @tp_richcompare@ */
477	0, /* @tp_weaklistoffset@ */
478	0, /* @tp_iter@ */
479	0, /* @tp_iternexr@ */
480	sharesplit_pymethods, /* @tp_methods@ */
481	0, /* @tp_members@ */
482	0, /* @tp_getset@ */
483	0, /* @tp_base@ */
484	0, /* @tp_dict@ */
485	0, /* @tp_descr_get@ */
486	0, /* @tp_descr_set@ */
487	0, /* @tp_dictoffset@ */
488	0, /* @tp_init@ */
489	PyType_GenericAlloc, /* @tp_alloc@ */
490	sharesplit_pynew, /* @tp_new@ */
491	0, /* @tp_free@ */
492	0 /* @tp_is_gc@ */
493	};
494
495	static PyObject sharejoin_pynew(PyTypeObject ty,
496	PyObject arg, PyObject kw)
497	{
498	unsigned t;
499	mp *m = 0;
500	share_pyobj *s;
501	char *kwlist[] = { "threshold", "modulus", 0 };
502	if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&O&:new", kwlist,
503	convuint, &t, convmp, &m))
504	goto end;
505	if (!t) VALERR("threshold must be nonzero");
506	s = (share_pyobj *)ty->tp_alloc(ty, 0);
507	share_create(&s->s, t);
508	s->s.p = m;
509	return ((PyObject *)s);
510	end:
511	mp_drop(m);
512	return (0);
513	}
514
515	static PyObject smeth_addedp(PyObject me, PyObject *arg)
516	{
517	unsigned i;
518	if (!PyArg_ParseTuple(arg, "O&:addedp", convuint, &i)) goto end;
519	return (getbool(share_addedp(SHARE_S(me), i)));
520	end:
521	return (0);
522	}
523
524	static PyObject smeth_add(PyObject me, PyObject *arg)
525	{
526	unsigned i;
527	mp *s = 0;
528	PyObject *rc = 0;
529	if (!PyArg_ParseTuple(arg, "O&O&:add", convuint, &i, convmp, &s)) goto end;
530	if (MP_NEGP(s) \|\| MP_CMP(s, >=, SHARE_S(me)->p))
531	VALERR("share out of range");
532	if (share_addedp(SHARE_S(me), i)) VALERR("this share already added");
533	if (SHARE_S(me)->i >= SHARE_S(me)->t) VALERR("enough shares already");
534	share_add(SHARE_S(me), i, s);
535	rc = PyInt_FromLong(SHARE_S(me)->t - SHARE_S(me)->i);
536	end:
537	mp_drop(s);
538	return (rc);
539	}
540
541	static PyObject smeth_combine(PyObject me, PyObject *arg)
542	{
543	PyObject *rc = 0;
544	if (!PyArg_ParseTuple(arg, ":combine")) goto end;
545	if (SHARE_S(me)->i < SHARE_S(me)->t) VALERR("not enough shares yet");
546	rc = mp_pywrap(share_combine(SHARE_S(me)));
547	end:
548	return (rc);
549	}
550
551	static PyMethodDef sharejoin_pymethods[] = {
552	#define METHNAME(name) smeth_##name
553	METH (addedp, "S.addedp(I) -> BOOL")
554	METH (add, "S.add(I, SHARE) -> REMAIN")
555	METH (combine, "S.combine() -> SECRET")
556	#undef METHNAME
557	{ 0 }
558	};
559
560	static PyObject sget_remain(PyObject me, void *hunoz)
561	{ return (PyInt_FromLong(SHARE_S(me)->t - SHARE_S(me)->i)); }
562
563	static PyGetSetDef sharejoin_pygetset[]= {
564	#define GETSETNAME(op, name) s##op##_##name
565	GET (remain, "S.remain -> REMAIN")
566	#undef GETSETNAME
567	{ 0 }
568	};
569
570	static PyTypeObject sharejoin_pytype_skel = {
571	PyObject_HEAD_INIT(&PyType_Type) 0, /* Header */
572	"catacomb.ShareJoin", /* @tp_name@ */
573	sizeof(share_pyobj), /* @tp_basicsize@ */
574	0, /* @tp_itemsize@ */
575
576	share_pydealloc, /* @tp_dealloc@ */
577	0, /* @tp_print@ */
578	0, /* @tp_getattr@ */
579	0, /* @tp_setattr@ */
580	0, /* @tp_compare@ */
581	0, /* @tp_repr@ */
582	0, /* @tp_as_number@ */
583	0, /* @tp_as_sequence@ */
584	0, /* @tp_as_mapping@ */
585	0, /* @tp_hash@ */
586	0, /* @tp_call@ */
587	0, /* @tp_str@ */
588	0, /* @tp_getattro@ */
589	0, /* @tp_setattro@ */
590	0, /* @tp_as_buffer@ */
591	Py_TPFLAGS_DEFAULT \| /* @tp_flags@ */
592	Py_TPFLAGS_BASETYPE,
593
594	/* @tp_doc@ */
595	"Prime field secret sharing: join shares to recover secret.",
596
597	0, /* @tp_traverse@ */
598	0, /* @tp_clear@ */
599	0, /* @tp_richcompare@ */
600	0, /* @tp_weaklistoffset@ */
601	0, /* @tp_iter@ */
602	0, /* @tp_iternexr@ */
603	sharejoin_pymethods, /* @tp_methods@ */
604	0, /* @tp_members@ */
605	sharejoin_pygetset, /* @tp_getset@ */
606	0, /* @tp_base@ */
607	0, /* @tp_dict@ */
608	0, /* @tp_descr_get@ */
609	0, /* @tp_descr_set@ */
610	0, /* @tp_dictoffset@ */
611	0, /* @tp_init@ */
612	PyType_GenericAlloc, /* @tp_alloc@ */
613	sharejoin_pynew, /* @tp_new@ */
614	0, /* @tp_free@ */
615	0 /* @tp_is_gc@ */
616	};
617
618	/----- Global stuff ------------------------------------------------------/
619
620	void share_pyinit(void)
621	{
622	INITTYPE(gfshare, root);
623	INITTYPE(gfsharesplit, gfshare);
624	INITTYPE(gfsharejoin, gfshare);
625	INITTYPE(share, root);
626	INITTYPE(sharesplit, share);
627	INITTYPE(sharejoin, share);
628	}
629
630	void share_pyinsert(PyObject *mod)
631	{
632	INSERT("GFShare", gfshare_pytype);
633	INSERT("GFShareSplit", gfsharesplit_pytype);
634	INSERT("GFShareJoin", gfsharejoin_pytype);
635	INSERT("Share", share_pytype);
636	INSERT("ShareSplit", sharesplit_pytype);
637	INSERT("ShareJoin", sharejoin_pytype);
638	}
639
640	/----- That's all, folks -------------------------------------------------/