477 lines
15 KiB
C
477 lines
15 KiB
C
#define PY_SSIZE_T_CLEAN
|
|
#include <Python.h>
|
|
#include "c_kzg_4844.h"
|
|
|
|
static void free_BLSFieldElement(PyObject *c) {
|
|
free(PyCapsule_GetPointer(c, "BLSFieldElement"));
|
|
}
|
|
|
|
static void free_G1(PyObject *c) {
|
|
free(PyCapsule_GetPointer(c, "G1"));
|
|
}
|
|
|
|
static void free_PolynomialEvalForm(PyObject *c) {
|
|
PolynomialEvalForm *p = PyCapsule_GetPointer(c, "PolynomialEvalForm");
|
|
free_polynomial(p);
|
|
free(p);
|
|
}
|
|
|
|
static void free_KZGSettings(PyObject *c) {
|
|
KZGSettings *s = PyCapsule_GetPointer(c, "KZGSettings");
|
|
free_trusted_setup(s);
|
|
free(s);
|
|
}
|
|
|
|
static PyObject* bytes_to_bls_field_wrap(PyObject *self, PyObject *args) {
|
|
PyObject *pybytes;
|
|
|
|
if (!PyArg_ParseTuple(args, "S", &pybytes) ||
|
|
PyBytes_Size(pybytes) != 32)
|
|
return PyErr_Format(PyExc_ValueError, "expected 32 bytes");
|
|
|
|
BLSFieldElement *out = (BLSFieldElement*)malloc(sizeof(BLSFieldElement));
|
|
|
|
if (out == NULL) return PyErr_NoMemory();
|
|
|
|
bytes_to_bls_field(out, (const uint8_t*)PyBytes_AsString(pybytes));
|
|
|
|
return PyCapsule_New(out, "BLSFieldElement", free_BLSFieldElement);
|
|
}
|
|
|
|
static PyObject* int_from_bls_field(PyObject *self, PyObject *args) {
|
|
PyObject *c;
|
|
|
|
if (!PyArg_UnpackTuple(args, "uint64s_from_BLSFieldElement", 1, 1, &c) ||
|
|
!PyCapsule_IsValid(c, "BLSFieldElement"))
|
|
return PyErr_Format(PyExc_ValueError, "expected a BLSFieldElement capsule");
|
|
|
|
uint64_t u[4];
|
|
uint64s_from_BLSFieldElement(u, PyCapsule_GetPointer(c, "BLSFieldElement"));
|
|
|
|
PyObject *out = PyLong_FromUnsignedLong(2);
|
|
PyObject *mult = PyLong_FromUnsignedLong(64);
|
|
PyObject *tmp, *two64 = PyNumber_Power(out, mult, Py_None);
|
|
Py_DECREF(out);
|
|
Py_DECREF(mult);
|
|
out = PyLong_FromUnsignedLong(0);
|
|
mult = PyLong_FromUnsignedLong(1);
|
|
for (uint8_t i = 0; i < 4; i++) {
|
|
c = PyLong_FromUnsignedLong(u[i]);
|
|
tmp = PyNumber_Multiply(mult, c);
|
|
Py_DECREF(c);
|
|
c = PyNumber_Add(out, tmp);
|
|
Py_DECREF(out);
|
|
Py_DECREF(tmp);
|
|
out = c;
|
|
c = PyNumber_Multiply(mult, two64);
|
|
Py_DECREF(mult);
|
|
mult = c;
|
|
}
|
|
Py_DECREF(mult);
|
|
Py_DECREF(two64);
|
|
|
|
return out;
|
|
}
|
|
|
|
static PyObject* alloc_polynomial_wrap(PyObject *self, PyObject *args) {
|
|
PyObject *a;
|
|
|
|
if (!PyArg_UnpackTuple(args, "alloc_polynomial_wrap", 1, 1, &a) ||
|
|
!PySequence_Check(a))
|
|
return PyErr_Format(PyExc_ValueError, "expected sequence");
|
|
|
|
PolynomialEvalForm *p = (PolynomialEvalForm*)malloc(sizeof(PolynomialEvalForm));
|
|
|
|
if (p == NULL) return PyErr_NoMemory();
|
|
|
|
Py_ssize_t n = PySequence_Length(a);
|
|
|
|
if (alloc_polynomial(p, n) != C_KZG_OK)
|
|
return PyErr_Format(PyExc_RuntimeError, "error allocating polynomial");
|
|
|
|
PyObject *e;
|
|
for (Py_ssize_t i = 0; i < n; i++) {
|
|
e = PySequence_GetItem(a, i);
|
|
if (!PyCapsule_IsValid(e, "BLSFieldElement")) {
|
|
free_polynomial(p);
|
|
free(p);
|
|
return PyErr_Format(PyExc_ValueError, "expected BLSFieldElement capsules");
|
|
}
|
|
memcpy(&p->values[i], PyCapsule_GetPointer(e, "BLSFieldElement"), sizeof(BLSFieldElement));
|
|
}
|
|
|
|
return PyCapsule_New(p, "PolynomialEvalForm", free_PolynomialEvalForm);
|
|
}
|
|
|
|
static PyObject* bytes_from_g1_wrap(PyObject *self, PyObject *args) {
|
|
PyObject *c;
|
|
|
|
if (!PyArg_UnpackTuple(args, "bytes_from_g1", 1, 1, &c) ||
|
|
!PyCapsule_IsValid(c, "G1"))
|
|
return PyErr_Format(PyExc_ValueError, "expected G1 capsule");
|
|
|
|
uint8_t bytes[48];
|
|
bytes_from_g1(bytes, PyCapsule_GetPointer(c, "G1"));
|
|
|
|
return PyBytes_FromStringAndSize((char*)bytes, 48);
|
|
}
|
|
|
|
static PyObject* compute_powers_wrap(PyObject *self, PyObject *args) {
|
|
PyObject *c;
|
|
PyObject *n;
|
|
|
|
if (!PyArg_UnpackTuple(args, "compute_powers", 2, 2, &c, &n) ||
|
|
!PyCapsule_IsValid(c, "BLSFieldElement") ||
|
|
!PyLong_Check(n))
|
|
return PyErr_Format(PyExc_ValueError, "expected a BLSFieldElement capsule and a number");
|
|
|
|
Py_ssize_t z = PyLong_AsSsize_t(n);
|
|
|
|
PyObject *out = PyList_New(z);
|
|
|
|
if (out == NULL) return PyErr_NoMemory();
|
|
|
|
BLSFieldElement *a = (BLSFieldElement*)calloc(z, sizeof(BLSFieldElement));
|
|
|
|
if (a == NULL) return PyErr_NoMemory();
|
|
|
|
compute_powers(a, PyCapsule_GetPointer(c, "BLSFieldElement"), z);
|
|
|
|
BLSFieldElement *f;
|
|
|
|
for (Py_ssize_t i = 0; i < z; i++) {
|
|
f = (BLSFieldElement*)malloc(sizeof(BLSFieldElement));
|
|
if (f == NULL) {
|
|
free(a);
|
|
return PyErr_NoMemory();
|
|
}
|
|
memcpy(f, &a[i], sizeof(BLSFieldElement));
|
|
PyList_SetItem(out, i, PyCapsule_New(f, "BLSFieldElement", free_BLSFieldElement));
|
|
}
|
|
|
|
free(a);
|
|
|
|
return out;
|
|
}
|
|
|
|
static PyObject* load_trusted_setup_wrap(PyObject *self, PyObject *args) {
|
|
PyObject *f;
|
|
|
|
if (!PyArg_ParseTuple(args, "U", &f))
|
|
return PyErr_Format(PyExc_ValueError, "expected a string");
|
|
|
|
KZGSettings *s = (KZGSettings*)malloc(sizeof(KZGSettings));
|
|
|
|
if (s == NULL) return PyErr_NoMemory();
|
|
|
|
if (load_trusted_setup(s, fopen(PyUnicode_AsUTF8(f), "r")) != C_KZG_OK) {
|
|
free(s);
|
|
return PyErr_Format(PyExc_RuntimeError, "error loading trusted setup");
|
|
}
|
|
|
|
return PyCapsule_New(s, "KZGSettings", free_KZGSettings);
|
|
}
|
|
|
|
static PyObject* blob_to_kzg_commitment_wrap(PyObject *self, PyObject *args) {
|
|
PyObject *a;
|
|
PyObject *c;
|
|
|
|
if (!PyArg_UnpackTuple(args, "alloc_polynomial_wrap", 2, 2, &a, &c) ||
|
|
!PySequence_Check(a) ||
|
|
!PyCapsule_IsValid(c, "KZGSettings"))
|
|
return PyErr_Format(PyExc_ValueError, "expected sequence and trusted setup");
|
|
|
|
Py_ssize_t n = PySequence_Length(a);
|
|
|
|
BLSFieldElement *blob = (BLSFieldElement*)calloc(n, sizeof(BLSFieldElement));
|
|
|
|
if (blob == NULL) return PyErr_NoMemory();
|
|
|
|
PyObject *e;
|
|
for (Py_ssize_t i = 0; i < n; i++) {
|
|
e = PySequence_GetItem(a, i);
|
|
if (!PyCapsule_IsValid(e, "BLSFieldElement")) {
|
|
free(blob);
|
|
return PyErr_Format(PyExc_ValueError, "expected BLSFieldElement capsules");
|
|
}
|
|
// TODO: could avoid copying if blob_to_kzg_commitment expected pointers instead of an array
|
|
memcpy(&blob[i], PyCapsule_GetPointer(e, "BLSFieldElement"), sizeof(BLSFieldElement));
|
|
}
|
|
|
|
KZGCommitment *k = (KZGCommitment*)malloc(sizeof(KZGCommitment));
|
|
|
|
if (k == NULL) {
|
|
free(blob);
|
|
return PyErr_NoMemory();
|
|
}
|
|
|
|
blob_to_kzg_commitment(k, blob, PyCapsule_GetPointer(c, "KZGSettings"));
|
|
|
|
free(blob);
|
|
|
|
return PyCapsule_New(k, "G1", free_G1);
|
|
}
|
|
|
|
static PyObject* vector_lincomb_wrap(PyObject *self, PyObject *args) {
|
|
PyObject *vs;
|
|
PyObject *fs;
|
|
|
|
if (!PyArg_UnpackTuple(args, "vector_lincomb", 2, 2, &vs, &fs) ||
|
|
!PySequence_Check(vs) ||
|
|
!PySequence_Check(fs))
|
|
return PyErr_Format(PyExc_ValueError, "expected two sequences");
|
|
|
|
Py_ssize_t n = PySequence_Length(vs);
|
|
if (PySequence_Length(fs) != n)
|
|
return PyErr_Format(PyExc_ValueError, "expected same-length sequences");
|
|
|
|
if (n == 0) { return fs; }
|
|
|
|
if (!PySequence_Check(PySequence_GetItem(vs, 0)))
|
|
return PyErr_Format(PyExc_ValueError, "expected sequence of sequences");
|
|
|
|
Py_ssize_t i, j, m = PySequence_Length(PySequence_GetItem(vs, 0));
|
|
|
|
const BLSFieldElement* *vectors = (const BLSFieldElement**)calloc(n * m, sizeof(BLSFieldElement*));
|
|
|
|
if (vectors == NULL) return PyErr_NoMemory();
|
|
|
|
PyObject *tmp, *out;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
if (!PySequence_Check(PySequence_GetItem(vs, i))) {
|
|
free(vectors);
|
|
return PyErr_Format(PyExc_ValueError, "expected sequence of sequences");
|
|
}
|
|
tmp = PySequence_GetItem(vs, i);
|
|
if (PySequence_Length(tmp) != m) {
|
|
free(vectors);
|
|
return PyErr_Format(PyExc_ValueError, "expected vectors of same length");
|
|
}
|
|
for (j = 0; j < m; j++) {
|
|
out = PySequence_GetItem(tmp, j);
|
|
if (!PyCapsule_IsValid(out, "BLSFieldElement")) {
|
|
free(vectors);
|
|
return PyErr_Format(PyExc_ValueError, "expected vectors of BLSFieldElement capsules");
|
|
}
|
|
vectors[i * m + j] = (BLSFieldElement*)PyCapsule_GetPointer(out, "BLSFieldElement");
|
|
}
|
|
}
|
|
|
|
const BLSFieldElement* *scalars = (const BLSFieldElement**)calloc(n, sizeof(BLSFieldElement*));
|
|
|
|
if (scalars == NULL) {
|
|
free(vectors);
|
|
return PyErr_NoMemory();
|
|
}
|
|
|
|
for (i = 0; i < n; i++) {
|
|
tmp = PySequence_GetItem(fs, i);
|
|
if (!PyCapsule_IsValid(tmp, "BLSFieldElement")) {
|
|
free(scalars);
|
|
free(vectors);
|
|
return PyErr_Format(PyExc_ValueError, "expected a BLSFieldElement capsule");
|
|
}
|
|
scalars[i] = (BLSFieldElement*)PyCapsule_GetPointer(tmp, "BLSFieldElement");
|
|
}
|
|
|
|
BLSFieldElement *r = (BLSFieldElement*)calloc(m, sizeof(BLSFieldElement));
|
|
|
|
if (r == NULL) {
|
|
free(scalars);
|
|
free(vectors);
|
|
return PyErr_NoMemory();
|
|
}
|
|
|
|
vector_lincomb(r, vectors, scalars, n, m);
|
|
|
|
free(scalars);
|
|
free(vectors);
|
|
|
|
out = PyList_New(m);
|
|
|
|
if (out == NULL) {
|
|
free(r);
|
|
return PyErr_NoMemory();
|
|
}
|
|
|
|
BLSFieldElement *f;
|
|
|
|
for (j = 0; j < m; j++) {
|
|
f = (BLSFieldElement*)malloc(sizeof(BLSFieldElement));
|
|
if (f == NULL) {
|
|
free(r);
|
|
return PyErr_NoMemory();
|
|
}
|
|
memcpy(f, &r[j], sizeof(BLSFieldElement));
|
|
PyList_SetItem(out, j, PyCapsule_New(f, "BLSFieldElement", free_BLSFieldElement));
|
|
}
|
|
|
|
free(r);
|
|
|
|
return out;
|
|
}
|
|
|
|
static PyObject* g1_lincomb_wrap(PyObject *self, PyObject *args) {
|
|
PyObject *gs, *fs;
|
|
|
|
if (!PyArg_UnpackTuple(args, "g1_lincomb", 2, 2, &gs, &fs) ||
|
|
!PySequence_Check(gs) ||
|
|
!PySequence_Check(fs) ||
|
|
PySequence_Length(gs) != PySequence_Length(fs))
|
|
return PyErr_Format(PyExc_ValueError, "expected same-length sequences");
|
|
|
|
Py_ssize_t i, n = PySequence_Length(gs);
|
|
|
|
KZGCommitment *k = (KZGCommitment*)malloc(sizeof(KZGCommitment));
|
|
|
|
if (k == NULL) return PyErr_NoMemory();
|
|
|
|
KZGCommitment* points = (KZGCommitment*)calloc(n, sizeof(KZGCommitment));
|
|
|
|
if (points == NULL) {
|
|
free(k);
|
|
return PyErr_NoMemory();
|
|
}
|
|
|
|
BLSFieldElement* scalars = (BLSFieldElement*)calloc(n, sizeof(BLSFieldElement));
|
|
|
|
if (scalars == NULL) {
|
|
free(points);
|
|
free(k);
|
|
return PyErr_NoMemory();
|
|
}
|
|
|
|
PyObject *tmp;
|
|
|
|
// TODO: could avoid copying if g1_lincomb expected pointers
|
|
|
|
for (i = 0; i < n; i++) {
|
|
tmp = PySequence_GetItem(gs, i);
|
|
if (!PyCapsule_IsValid(tmp, "G1")) {
|
|
free(scalars);
|
|
free(points);
|
|
free(k);
|
|
return PyErr_Format(PyExc_ValueError, "expected group elements");
|
|
}
|
|
memcpy(&points[i], PyCapsule_GetPointer(tmp, "G1"), sizeof(KZGCommitment));
|
|
|
|
tmp = PySequence_GetItem(fs, i);
|
|
if (!PyCapsule_IsValid(tmp, "BLSFieldElement")) {
|
|
free(scalars);
|
|
free(points);
|
|
free(k);
|
|
return PyErr_Format(PyExc_ValueError, "expected field elements");
|
|
}
|
|
memcpy(&scalars[i], PyCapsule_GetPointer(tmp, "BLSFieldElement"), sizeof(BLSFieldElement));
|
|
}
|
|
|
|
g1_lincomb(k, points, scalars, n);
|
|
|
|
free(scalars);
|
|
free(points);
|
|
|
|
return PyCapsule_New(k, "G1", free_G1);
|
|
}
|
|
|
|
static PyObject* compute_kzg_proof_wrap(PyObject *self, PyObject *args) {
|
|
PyObject *p, *x, *s;
|
|
|
|
if (!PyArg_UnpackTuple(args, "compute_kzg_proof", 3, 3, &p, &x, &s) ||
|
|
!PyCapsule_IsValid(p, "PolynomialEvalForm") ||
|
|
!PyCapsule_IsValid(x, "BLSFieldElement") ||
|
|
!PyCapsule_IsValid(s, "KZGSettings"))
|
|
return PyErr_Format(PyExc_ValueError, "expected polynomial, field element, trusted setup");
|
|
|
|
KZGProof *k = (KZGProof*)malloc(sizeof(KZGProof));
|
|
|
|
if (k == NULL) return PyErr_NoMemory();
|
|
|
|
if (compute_kzg_proof(k,
|
|
PyCapsule_GetPointer(p, "PolynomialEvalForm"),
|
|
PyCapsule_GetPointer(x, "BLSFieldElement"),
|
|
PyCapsule_GetPointer(s, "KZGSettings")) != C_KZG_OK) {
|
|
free(k);
|
|
return PyErr_Format(PyExc_RuntimeError, "compute_kzg_proof failed");
|
|
}
|
|
|
|
return PyCapsule_New(k, "G1", free_G1);
|
|
}
|
|
|
|
static PyObject* evaluate_polynomial_in_evaluation_form_wrap(PyObject *self, PyObject *args) {
|
|
PyObject *p, *x, *s;
|
|
|
|
if (!PyArg_UnpackTuple(args, "evaluate_polynomial_in_evaluation_form", 3, 3, &p, &x, &s) ||
|
|
!PyCapsule_IsValid(p, "PolynomialEvalForm") ||
|
|
!PyCapsule_IsValid(x, "BLSFieldElement") ||
|
|
!PyCapsule_IsValid(s, "KZGSettings"))
|
|
return PyErr_Format(PyExc_ValueError, "expected polynomial, field element, trusted setup");
|
|
|
|
BLSFieldElement *y = (BLSFieldElement*)malloc(sizeof(BLSFieldElement));
|
|
|
|
if (y == NULL) return PyErr_NoMemory();
|
|
|
|
if (evaluate_polynomial_in_evaluation_form(y,
|
|
PyCapsule_GetPointer(p, "PolynomialEvalForm"),
|
|
PyCapsule_GetPointer(x, "BLSFieldElement"),
|
|
PyCapsule_GetPointer(s, "KZGSettings")) != C_KZG_OK) {
|
|
free(y);
|
|
return PyErr_Format(PyExc_RuntimeError, "evaluate_polynomial_in_evaluation_form failed");
|
|
}
|
|
|
|
return PyCapsule_New(y, "BLSFieldElement", free_BLSFieldElement);
|
|
}
|
|
|
|
static PyObject* verify_kzg_proof_wrap(PyObject *self, PyObject *args) {
|
|
PyObject *c, *x, *y, *p, *s;
|
|
|
|
if (!PyArg_UnpackTuple(args, "verify_kzg_proof", 5, 5, &c, &x, &y, &p, &s) ||
|
|
!PyCapsule_IsValid(c, "G1") ||
|
|
!PyCapsule_IsValid(x, "BLSFieldElement") ||
|
|
!PyCapsule_IsValid(y, "BLSFieldElement") ||
|
|
!PyCapsule_IsValid(p, "G1") ||
|
|
!PyCapsule_IsValid(s, "KZGSettings"))
|
|
return PyErr_Format(PyExc_ValueError,
|
|
"expected commitment, field element, field element, proof, trusted setup");
|
|
|
|
bool out;
|
|
|
|
if (verify_kzg_proof(&out,
|
|
PyCapsule_GetPointer(c, "G1"),
|
|
PyCapsule_GetPointer(x, "BLSFieldElement"),
|
|
PyCapsule_GetPointer(y, "BLSFieldElement"),
|
|
PyCapsule_GetPointer(p, "G1"),
|
|
PyCapsule_GetPointer(s, "KZGSettings")) != C_KZG_OK)
|
|
return PyErr_Format(PyExc_RuntimeError, "verify_kzg_proof failed");
|
|
|
|
if (out) Py_RETURN_TRUE; else Py_RETURN_FALSE;
|
|
}
|
|
|
|
static PyMethodDef ckzgmethods[] = {
|
|
{"bytes_from_g1", bytes_from_g1_wrap, METH_VARARGS, "Convert a group element to 48 bytes"},
|
|
{"int_from_bls_field", int_from_bls_field, METH_VARARGS, "Convert a field element to a 256-bit int"},
|
|
{"bytes_to_bls_field", bytes_to_bls_field_wrap, METH_VARARGS, "Convert 32 bytes to a field element"},
|
|
{"alloc_polynomial", alloc_polynomial_wrap, METH_VARARGS, "Create a PolynomialEvalForm from a sequence of field elements"},
|
|
{"load_trusted_setup", load_trusted_setup_wrap, METH_VARARGS, "Load trusted setup from file path"},
|
|
{"blob_to_kzg_commitment", blob_to_kzg_commitment_wrap, METH_VARARGS, "Create a commitment from a sequence of field elements"},
|
|
{"compute_powers", compute_powers_wrap, METH_VARARGS, "Create a list of powers of a field element"},
|
|
{"vector_lincomb", vector_lincomb_wrap, METH_VARARGS, "Multiply a matrix of field elements with a vector"},
|
|
{"g1_lincomb", g1_lincomb_wrap, METH_VARARGS, "Linear combination of group elements with field elements"},
|
|
{"compute_kzg_proof", compute_kzg_proof_wrap, METH_VARARGS, "Compute KZG proof for polynomial at point"},
|
|
{"evaluate_polynomial_in_evaluation_form", evaluate_polynomial_in_evaluation_form_wrap, METH_VARARGS, "Evaluate polynomial"},
|
|
{"verify_kzg_proof", verify_kzg_proof_wrap, METH_VARARGS, "Verify KZG proof"},
|
|
{NULL, NULL, 0, NULL}
|
|
};
|
|
|
|
static struct PyModuleDef ckzg = {
|
|
PyModuleDef_HEAD_INIT,
|
|
"ckzg",
|
|
NULL,
|
|
-1,
|
|
ckzgmethods
|
|
};
|
|
|
|
PyMODINIT_FUNC PyInit_ckzg(void) {
|
|
return PyModule_Create(&ckzg);
|
|
}
|