charm-crypto-framework 0.61.1__cp313-cp313-macosx_10_13_universal2.whl

charm/core/math/integer/integermodule.h

@@ -0,0 +1,145 @@
+/*
+ * Charm-Crypto is a framework for rapidly prototyping cryptosystems.
+ *
+ * Charm-Crypto is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Charm-Crypto 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Charm-Crypto. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Please contact the charm-crypto dev team at support@charm-crypto.com
+ * for any questions.
+ */
+
+/*
+ *   @file    integermodule.h
+ *
+ *   @brief   charm interface over GMP multi-precision integers
+ *
+ *   @author  jakinye3@jhu.edu
+ *
+ ************************************************************************/
+
+#ifndef INTEGERMODULE_H
+#define INTEGERMODULE_H
+
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif
+
+/* Define MS_WIN64 to get correct PYLONG_BITS_IN_DIGIT on Windows. */
+#if PY_MINOR_VERSION <= 10 && defined(_WIN64) && !defined(MS_WIN64)
+#define MS_WIN64
+#endif
+
+#include <Python.h>
+#include <stdio.h>
+#include <string.h>
+#include <structmember.h>
+
+#if PY_MINOR_VERSION <= 10
+  #include <longintrepr.h>
+#else
+  #include <cpython/longintrepr.h>				/* for conversions */
+#endif
+
+#include <math.h>
+#include <string.h>
+#include <gmp.h>
+#include "benchmarkmodule.h"
+#include "base64.h"
+/* used to initialize the RNG */
+#include <openssl/objects.h>
+#include <openssl/rand.h>
+#include <openssl/bn.h>
+#include <openssl/sha.h>
+#include <openssl/evp.h>
+
+/* integermath */
+#define MAX_RUN  	25
+#define HASH_LEN 	SHA256_DIGEST_LENGTH
+#define MSG_LEN  	128
+
+#define ErrorMsg(msg) \
+	PyErr_SetString(IntegerError, msg); \
+	return NULL;
+
+#define Convert_Types(left, right, lhs, rhs, foundLHS, foundRHS, lhs_mpz, rhs_mpz, errorOccured)  \
+	if(PyInteger_Check(left)) { \
+		lhs = (Integer *) left; } \
+	else if(PyLong_Check(left)) { \
+		longObjToMPZ(lhs_mpz, left);	\
+		foundLHS = TRUE;  } \
+	else { errorOccured = TRUE; } \
+						\
+	if(PyInteger_Check(right)) {  \
+		rhs = (Integer *) right; } \
+	else if(PyLong_Check(right)) {  \
+		longObjToMPZ(rhs_mpz, right);	\
+		foundRHS = TRUE;  } \
+	else { errorOccured = TRUE; }
+
+#define Convert_Types2(o1, o2, lhs, rhs, foundLHS, foundRHS)  \
+	if(PyInteger_Check(o1)) { \
+		lhs = (Integer *) o1; } \
+	else if(PyLong_Check(o1)) { \
+		foundLHS = TRUE;  } \
+	else { ErrorMsg("invalid left operand type."); } \
+							\
+	if(PyInteger_Check(o2)) {  \
+		rhs = (Integer *) o2; } \
+	else if(PyLong_Check(o2)) {  \
+		foundRHS = TRUE; }  \
+	else { ErrorMsg("invalid right operand type."); }
+
+//#ifdef BENCHMARK_ENABLED
+//static Benchmark *dBench;
+//#endif
+
+/* Index numbers for different hash functions.  These are all implemented as SHA1(index || message).	*/
+#define HASH_FUNCTION_STR_TO_Zr_CRH		0
+#define HASH_FUNCTION_Zr_TO_G1_ROM		1
+#define HASH_FUNCTION_KEM_DERIVE		2
+#define RAND_MAX_BYTES					2048
+
+// declare global gmp_randstate_t state object. Initialize based on /dev/random if linux
+// then make available to all random functions
+PyTypeObject IntegerType;
+static PyObject *IntegerError;
+#define PyInteger_Check(obj) PyObject_TypeCheck(obj, &IntegerType)
+#define PyInteger_Init(obj1, obj2) obj1->initialized && obj2->initialized
+
+typedef struct {
+	PyObject_HEAD
+	mpz_t m;
+	mpz_t e;
+	int initialized;
+} Integer;
+
+PyMethodDef Integer_methods[];
+PyNumberMethods integer_number;
+
+void	Integer_dealloc(Integer* self);
+PyObject *Integer_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
+int Integer_init(Integer *self, PyObject *args, PyObject *kwds);
+PyObject *Integer_print(Integer *self);
+Integer *createNewInteger(void);
+void print_mpz(mpz_t x, int base);
+void print_bn_dec(const BIGNUM *bn);
+
+#define EXIT_IF(check, msg) \
+	if(check) { 						\
+	PyErr_SetString(IntegerError, msg); \
+	return NULL;	}
+
+
+#endif
+
+

charm/core/math/integer.pyi

@@ -0,0 +1,76 @@
+"""Type stubs for charm.core.math.integer C extension module."""
+
+from __future__ import annotations
+
+from typing import overload
+
+class Element:
+    """Integer element, optionally with modulus for modular arithmetic."""
+
+    @overload
+    def __init__(self, number: int) -> None: ...
+    @overload
+    def __init__(self, number: Element) -> None: ...
+    @overload
+    def __init__(self, number: int, modulus: int) -> None: ...
+    @overload
+    def __init__(self, number: int, modulus: Element) -> None: ...
+    @overload
+    def __init__(self, number: Element, modulus: int) -> None: ...
+    @overload
+    def __init__(self, number: Element, modulus: Element) -> None: ...
+    def set(self, other: Element) -> bool: ...
+    def isCoPrime(self, other: Element | int) -> bool: ...
+    def isCongruent(self, a: int, n: int) -> bool: ...
+
+    # Arithmetic operations
+    def __add__(self, other: Element | int) -> Element: ...
+    def __radd__(self, other: Element | int) -> Element: ...
+    def __sub__(self, other: Element | int) -> Element: ...
+    def __rsub__(self, other: Element | int) -> Element: ...
+    def __mul__(self, other: Element | int) -> Element: ...
+    def __rmul__(self, other: Element | int) -> Element: ...
+    def __truediv__(self, other: Element | int) -> Element: ...
+    def __rtruediv__(self, other: Element | int) -> Element: ...
+    def __mod__(self, other: Element | int) -> Element: ...
+    def __rmod__(self, other: Element | int) -> Element: ...
+    def __pow__(self, other: Element | int) -> Element: ...
+    def __rpow__(self, other: Element | int) -> Element: ...
+    def __neg__(self) -> Element: ...
+    def __invert__(self) -> Element: ...
+    def __xor__(self, other: Element | int) -> Element: ...
+    def __rxor__(self, other: Element | int) -> Element: ...
+
+    # Comparison operations
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __lt__(self, other: Element | int) -> bool: ...
+    def __le__(self, other: Element | int) -> bool: ...
+    def __gt__(self, other: Element | int) -> bool: ...
+    def __ge__(self, other: Element | int) -> bool: ...
+
+    # Conversion
+    def __int__(self) -> int: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+    def __hash__(self) -> int: ...
+
+# Module-level functions
+def randomBits(bits: int) -> Element: ...
+def random(n: Element | int) -> Element: ...
+def randomPrime(bits: int) -> Element: ...
+def isPrime(n: Element | int) -> bool: ...
+def encode(message: bytes, modulus: Element | int) -> Element: ...
+def decode(element: Element) -> bytes: ...
+def hashInt(value: bytes, modulus: Element | int) -> Element: ...
+def bitsize(n: Element | int) -> int: ...
+def legendre(a: Element | int, p: Element | int) -> int: ...
+def gcd(a: Element | int, b: Element | int) -> Element: ...
+def lcm(a: Element | int, b: Element | int) -> Element: ...
+def serialize(element: Element) -> bytes: ...
+def deserialize(data: bytes) -> Element: ...
+def int2Bytes(element: Element) -> bytes: ...
+def toInt(element: Element) -> Element: ...
+def getMod(element: Element) -> Element: ...
+def reduce(element: Element) -> Element: ...
+

charm/core/math/pairing/miracl/miracl_config.h

@@ -0,0 +1,37 @@
+
+/* auto-generated configuration */
+//#define BUILD_MNT_CURVE  0
+//#define BUILD_BN_CURVE   0
+#define PAD_SIZE		 2 // 2 bytes for zero padding on deserialization
+
+#if BUILD_MNT_CURVE == 1
+// k=6 MNT curve
+#define MR_PAIRING_MNT
+#define ASYMMETRIC		1
+#define AES_SECURITY 	80 // for MNT-160
+#define BIG_SIZE		20
+#define MAX_LEN    		BIG_SIZE + PAD_SIZE // 20 bytes necessary for representation of ints
+
+#include "pairing_3.h"
+
+#elif BUILD_BN_CURVE == 1
+
+#define MR_PAIRING_BN
+#define ASYMMETRIC		1
+#define AES_SECURITY 	128 // for BN-256
+#define BIG_SIZE		32
+#define MAX_LEN			BIG_SIZE + PAD_SIZE // 32 bytes necessary, 2 for zero padding on deserialization
+
+#include "pairing_3.h"
+
+#elif BUILD_SS_CURVE == 1
+// super-singular curve over GF(P) where k=2 (large prime)
+#define MR_PAIRING_SSP
+#define ASYMMETRIC		0
+#define AES_SECURITY	80 // for SS512, 128 for SS1536
+#define BIG_SIZE		64
+#define MAX_LEN			BIG_SIZE + PAD_SIZE // 64 bytes necessary, 2 for zero padding on deserialization
+#include "pairing_1.h"
+
+#endif
+

charm/core/math/pairing/miracl/miracl_interface.h

@@ -0,0 +1,118 @@
+/*
+ * Charm-Crypto is a framework for rapidly prototyping cryptosystems.
+ *
+ * Charm-Crypto is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Charm-Crypto 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Charm-Crypto. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Please contact the charm-crypto dev team at support@charm-crypto.com
+ * for any questions.
+ */
+
+/*
+*   @file    miracl_interface.h
+*
+*   @brief   charm interface over MIRACL's pairing-based crypto C++ classes
+*
+*   @author  jakinye3@jhu.edu
+*
+************************************************************************/
+
+#include <gmp.h>
+
+typedef void pairing_t;
+typedef void element_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum Curve {MNT, SS, BLS, NONE_C}; // control what type of curve we are dealing with
+enum Group {ZR_t = 0, G1_t, G2_t, GT_t, NONE_G}; // clashes with types in pairing_3.h
+typedef enum Group Group_t;
+typedef enum Curve Curve_t;
+
+#define TRUE		1
+#define FALSE		0
+#define CF        	2 // Co-factor = 2 in MNT curves
+#define MAX_LEN		256
+#define LEN_BITS	4
+#define aes_block_size 16
+
+pairing_t *pairing_init(int securitylevel);
+void pairing_clear(pairing_t *pairing);
+// to clean up the mriacl system completely.NOTE: Make sure miracl PFC classes are patched.
+void miracl_clean();
+element_t *order(pairing_t *pairing);
+
+element_t *element_init_ZR(int value);
+element_t *_element_init_G1(void);
+element_t *_element_init_G2(void);
+element_t *_element_init_GT(const pairing_t *pairing);
+void element_random(Group_t type, const pairing_t *pairing, element_t *e);
+void element_printf(Group_t type, const element_t *e);
+int _element_length_to_str(Group_t type, const element_t *e);
+int _element_to_str(unsigned char **data_str, Group_t type, const element_t *e);
+
+void _element_add(Group_t type, element_t *c, const element_t *a, const element_t *b, const element_t *o); // c = a + b
+void _element_sub(Group_t type, element_t *c, const element_t *a, const element_t *b, const element_t *o); // c = (a - b) % o
+void _element_mul(Group_t type, element_t *c, const element_t *a, const element_t *b, const element_t *o);
+void _element_mul_si(Group_t type, const pairing_t *pairing, element_t *c, const element_t *a, const signed long int b, const element_t *o);
+void _element_mul_zn(Group_t type, const pairing_t *pairing, element_t *c, const element_t *a, const element_t *b, const element_t *o);
+void _element_div(Group_t type, element_t *c, const element_t *a, const element_t *b, const element_t *o); // c = a / b
+
+// c = a (G1, G2 or GT) ^ b (ZR)
+element_t *_element_pow_zr(Group_t type, const pairing_t *pairing, element_t *a, element_t *b, element_t *o);
+//element_t *_element_pow_zr(Group_t type, const pairing_t *pairing, const element_t *a, const element_t *b, const element_t *o);
+element_t *_element_pow_zr_zr(Group_t type, const pairing_t *pairing, const element_t *a, const int b, const element_t *o);
+element_t *_element_neg(Group_t type, const element_t *e, const element_t *o);
+//void _element_inv(Group_t type, const element_t *a, element_t *b, element_t *o);
+void _element_inv(Group_t type, const pairing_t *pairing, const element_t *a, element_t *b, element_t *o);
+
+element_t *hash_then_map(Group_t type, const pairing_t *pairing, char *data, int len);
+element_t *_element_from_hash(Group_t type, const pairing_t *pairing, void *data, int len);
+
+int element_is_member(Curve_t ctype, Group_t type, const pairing_t *pairing, element_t *e);
+int element_is_value(Group_t type, element_t *n, int value);
+
+int _element_cmp(Group_t type, element_t *a, element_t *b);
+void _element_set_si(Group_t type, element_t *dst, const signed long int src);
+int _element_setG1(Group_t type, element_t *c, const element_t *a, const element_t *b);
+void _element_set(Curve_t ctype, Group_t type, element_t *dst, const element_t *src);
+char *print_mpz(mpz_t x, int base);
+void _element_set_mpz(Group_t type, element_t *dst, mpz_t src);
+void _element_to_mpz(Group_t type, element_t *src, mpz_t dst);
+element_t *_element_pairing_type3(const pairing_t *pairing, const element_t *in1, const element_t *in2);
+element_t *_element_prod_pairing_type3(const pairing_t *pairing, const element_t **in1, const element_t **in2, int length);
+
+// I/O functions start
+int _element_length_in_bytes(Curve_t ctype, Group_t type, element_t *e);
+int _element_to_bytes(unsigned char *data, Curve_t ctype, Group_t type, element_t *e);
+element_t *_element_from_bytes(Curve_t ctype, Group_t type, unsigned char *data);
+// I/O functiond end
+
+void element_delete(Group_t type, element_t *e);
+
+void _init_hash(const pairing_t *pairing);
+void _element_add_str_hash(const pairing_t *pairing, void *data, int len);
+void _element_add_to_hash(Group_t type, const pairing_t *pairing, const element_t *e);
+element_t *finish_hash(Group_t type, const pairing_t *pairing);
+
+void _element_hash_key(const pairing_t *pairing, Group_t type, element_t *e, void *data, int len);
+
+int aes_encrypt(char *key, char *message, int len, char **out);
+int aes_decrypt(char *key, char *ciphertext, int len, char **out);
+
+#ifdef __cplusplus
+}
+#endif
+

charm/core/math/pairing/miracl/miracl_interface2.h

@@ -0,0 +1,126 @@
+/*
+ * Charm-Crypto is a framework for rapidly prototyping cryptosystems.
+ *
+ * Charm-Crypto is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Charm-Crypto 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Charm-Crypto. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Please contact the charm-crypto dev team at support@charm-crypto.com
+ * for any questions.
+ */
+
+/*
+*   @file    miracl_interface.h
+*
+*   @brief   charm interface over MIRACL's pairing-based crypto C++ classes
+*
+*   @author  jakinye3@jhu.edu
+*
+************************************************************************/
+#include <gmp.h>
+
+typedef void pairing_t;
+typedef void element_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum Curve {MNT, BN, SS, NONE_C}; // control what type of curve we are dealing with
+#if (BUILD_MNT_CURVE == 1 || BUILD_BN_CURVE == 1)
+enum Group {pyZR_t = 0, pyG1_t, pyG2_t, pyGT_t, NONE_G}; // clashes with types in pairing_3.h
+#else
+enum Group {pyZR_t = 0, pyG1_t, pyGT_t, NONE_G};
+#define pyG2_t 	pyG1_t // for backwards compatibility
+#define G2 	 	G1
+#endif
+
+typedef enum Group Group_t;
+typedef enum Curve Curve_t;
+
+#define TRUE		1
+#define FALSE		0
+#define CF        	2 // Co-factor = 2 in MNT curves
+#define LEN_BITS	4
+#define aes_block_size 16
+
+pairing_t *pairing_init(int securitylevel);
+void pairing_clear(pairing_t *pairing);
+// to clean up the mriacl system completely.NOTE: Make sure miracl PFC classes are patched.
+void miracl_clean(void);
+element_t *order(pairing_t *pairing);
+element_t *element_gt(const pairing_t *pairing);
+
+element_t *element_init_ZR(int value);
+element_t *_element_init_G1(void);
+element_t *_element_init_G2(void);
+element_t *_element_init_GT(const pairing_t *pairing);
+int _element_pp_init(const pairing_t *pairing, Group_t type, element_t *e);
+void element_random(Group_t type, const pairing_t *pairing, element_t *e);
+void element_printf(Group_t type, const element_t *e);
+int _element_length_to_str(Group_t type, const element_t *e);
+int _element_to_str(unsigned char **data_str, Group_t type, const element_t *e);
+
+void _element_add(Group_t type, element_t *c, const element_t *a, const element_t *b, const element_t *o); // c = a + b
+void _element_sub(Group_t type, element_t *c, const element_t *a, const element_t *b, const element_t *o); // c = (a - b) % o
+void _element_mul(Group_t type, element_t *c, const element_t *a, const element_t *b, const element_t *o);
+void _element_mul_si(Group_t type, const pairing_t *pairing, element_t *c, const element_t *a, const signed long int b, const element_t *o);
+void _element_mul_zn(Group_t type, const pairing_t *pairing, element_t *c, const element_t *a, const element_t *b, const element_t *o);
+void _element_div(Group_t type, element_t *c, const element_t *a, const element_t *b, const element_t *o); // c = a / b
+
+// c = a (G1, G2 or GT) ^ b (ZR)
+element_t *_element_pow_zr(Group_t type, const pairing_t *pairing, element_t *a, element_t *b, element_t *o);
+//element_t *_element_pow_zr(Group_t type, const pairing_t *pairing, const element_t *a, const element_t *b, const element_t *o);
+element_t *_element_pow_zr_zr(Group_t type, const pairing_t *pairing, const element_t *a, const int b, const element_t *o);
+element_t *_element_neg(Group_t type, const element_t *e, const element_t *o);
+//void _element_inv(Group_t type, const element_t *a, element_t *b, element_t *o);
+void _element_inv(Group_t type, const pairing_t *pairing, const element_t *a, element_t *b, element_t *o);
+
+element_t *hash_then_map(Group_t type, const pairing_t *pairing, char *data, int len);
+element_t *_element_from_hash(Group_t type, const pairing_t *pairing, void *data, int len);
+
+int element_is_member(Curve_t ctype, Group_t type, const pairing_t *pairing, element_t *e);
+int element_is_value(Group_t type, element_t *n, int value);
+
+int _element_cmp(Group_t type, element_t *a, element_t *b);
+void _element_set_si(Group_t type, element_t *dst, const signed long int src);
+int _element_setG1(Group_t type, element_t *c, const element_t *a, const element_t *b);
+void _element_set(Curve_t ctype, Group_t type, element_t *dst, const element_t *src);
+char *print_mpz(mpz_t x, int base);
+void _element_set_mpz(Group_t type, element_t *dst, mpz_t src);
+void _element_to_mpz(Group_t type, element_t *src, mpz_t dst);
+
+element_t *_element_pairing(const pairing_t *pairing, const element_t *in1, const element_t *in2);
+element_t *_element_prod_pairing(const pairing_t *pairing, const element_t **in1, const element_t **in2, int length);
+
+// I/O functions start
+int _element_length_in_bytes(Curve_t ctype, Group_t type, element_t *e);
+int _element_to_bytes(unsigned char *data, Curve_t ctype, Group_t type, element_t *e);
+element_t *_element_from_bytes(Curve_t ctype, Group_t type, unsigned char *data);
+// I/O functiond end
+
+void element_delete(Group_t type, element_t *e);
+
+void _init_hash(const pairing_t *pairing);
+void _element_add_str_hash(const pairing_t *pairing, char *data, int len);
+void _element_add_to_hash(Group_t type, const pairing_t *pairing, const element_t *e);
+element_t *finish_hash(Group_t type, const pairing_t *pairing);
+
+void _element_hash_key(const pairing_t *pairing, Group_t type, element_t *e, void *data, int len);
+
+int aes_encrypt(char *key, char *message, int len, char **out);
+int aes_decrypt(char *key, char *ciphertext, int len, char **out);
+
+#ifdef __cplusplus
+}
+#endif
+