charm-crypto-lite 0.61.1__cp314-cp314-macosx_10_15_universal2.whl

charm_lite/core/math/elliptic_curve/ecmodule.h

@@ -0,0 +1,230 @@
+/*
+ * 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    ecmodule.h
+ *
+ *   @brief   charm interface over OpenSSL Ellipic-curve module
+ *
+ *   @author  jakinye3@jhu.edu
+ *
+ ************************************************************************/
+
+#ifndef ECMODULE_H
+#define ECMODULE_H
+
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif
+
+#include <Python.h>
+#include <structmember.h>
+
+#if PY_MINOR_VERSION <= 10
+  #include <longintrepr.h>
+#else
+  #include <cpython/longintrepr.h>				/* for conversions */
+#endif
+
+#include <math.h>
+#include "benchmarkmodule.h"
+#include "base64.h"
+
+/* Openssl header files */
+#include <openssl/ec.h>
+#include <openssl/err.h>
+#include <openssl/obj_mac.h>
+#include <openssl/objects.h>
+#include <openssl/rand.h>
+#include <openssl/bn.h>
+#include <openssl/sha.h>
+#include <openssl/evp.h>
+#ifdef BENCHMARK_ENABLED
+#include "benchmark_util.h"
+#endif
+
+
+//#define DEBUG	1
+#define TRUE	1
+#define FALSE	0
+#define BYTE	8
+#define ID_LEN  BYTE
+#define BASE_DEC 10
+#define BASE_HEX 16
+#define MAX_BUF  256
+#define RAND_MAX_BYTES	2048
+/* Index numbers for different hash functions.  These are all implemented as SHA1(index || message).	*/
+#define HASH_FUNCTION_STR_TO_ZR_CRH		10
+#define HASH_FUNCTION_STR_TO_G_CRH		11
+#define HASH_FUNCTION_KEM_DERIVE		12
+#define HASH_LEN						SHA256_DIGEST_LENGTH
+#define RESERVED_ENCODING_BYTES			4
+
+PyTypeObject ECType;
+PyTypeObject ECGroupType;
+PyTypeObject OperationType;
+static PyObject *PyECErrorObject;
+#define PyEC_Check(obj) PyObject_TypeCheck(obj, &ECType)
+#define PyECGroup_Check(obj) PyObject_TypeCheck(obj, &ECGroupType)
+enum Group {ZR = 0, G, NONE_G};
+typedef enum Group GroupType;
+
+PyMethodDef ECElement_methods[];
+PyNumberMethods ecc_number;
+
+#ifdef BENCHMARK_ENABLED
+typedef struct {
+	PyObject_HEAD
+	int op_init;
+	int exp_ZR, exp_G;
+	int mul_ZR, mul_G;
+	int div_ZR, div_G;
+
+	int add_ZR, add_G;
+	int sub_ZR, sub_G;
+} Operations;
+#endif
+
+typedef struct {
+	PyObject_HEAD
+	EC_GROUP *ec_group;
+	int group_init;
+	int nid;
+	BN_CTX *ctx;
+	BIGNUM *order;
+#ifdef BENCHMARK_ENABLED
+    Benchmark *dBench;
+    Operations *gBench;
+	uint8_t bench_id[ID_LEN+1];
+#endif
+} ECGroup;
+
+typedef struct {
+	PyObject_HEAD
+	GroupType type;
+	ECGroup *group;
+	EC_POINT *P;
+	BIGNUM *elemZ;
+	int point_init;
+} ECElement;
+
+#define PyLong_ToUnsignedLong(o) PyLong_AsUnsignedLong(o)
+#define PyLongCheck(o) PyLong_Check(o)
+
+#define ErrorMsg(msg) \
+	PyErr_SetString(PyECErrorObject, msg); \
+	debug("%s: %d error occured here!", __FUNCTION__, __LINE__); \
+	return NULL;
+
+#define Check_Types2(o1, o2, lhs, rhs, foundLHS, foundRHS)  \
+	if(PyEC_Check(o1)) { \
+		lhs = (ECElement *) o1; \
+		debug("found a lhs object.\n"); \
+    } \
+	else if(PyLongCheck(o1)) { \
+		foundLHS = TRUE;  }		\
+	else  {  ErrorMsg("invalid type specified.");    \
+		}				\
+	if(PyEC_Check(o2)) {  \
+		rhs = (ECElement *) o2; \
+		debug("found a rhs object.\n"); \
+    } \
+	else if(PyLongCheck(o2)) {  \
+		foundRHS = TRUE; }		\
+	else  {  ErrorMsg("invalid type specified.");   \
+		}
+
+#define Group_NULL(obj) if(obj->ec_group == NULL) {  \
+	PyErr_SetString(PyECErrorObject, "group object not allocated."); \
+	return NULL;    }
+
+#define VERIFY_GROUP(obj) \
+	if(!PyECGroup_Check(obj))  {  \
+		PyErr_SetString(PyECErrorObject, "not an ecc object."); return NULL; } \
+	if(obj->group_init == FALSE || obj->ec_group == NULL) { \
+		PyErr_SetString(PyECErrorObject, "group object not initialized.");   \
+	return NULL;	}
+
+#define Point_Init(obj) if(!obj->point_init) {  	\
+	printf("ERROR: element not initialized.\n");		\
+	return NULL;  }
+
+#define isPoint(a) a->type == G
+#define ElementG(a, b) a->type == G && b->type == G
+#define ElementZR(a, b) a->type == ZR && b->type == ZR
+
+void setBigNum(PyLongObject *obj, BIGNUM **value);
+PyObject *ECElement_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
+int ECElement_init(ECElement *self, PyObject *args, PyObject *kwds);
+PyObject *ECElement_call(ECElement *intObject, PyObject *args, PyObject *kwds);
+PyObject *ECElement_print(ECElement *self);
+void	ECElement_dealloc(ECElement* self);
+
+ECElement *negatePoint(ECElement *self);
+ECElement *invertECElement(ECElement *self);
+int hash_to_bytes(uint8_t *input_buf, int input_len, uint8_t *output_buf, int hash_len, uint8_t hash_prefix);
+void set_element_from_hash(ECElement *self, uint8_t *input, int input_len);
+
+#define EXIT_IF(check, msg) \
+	if(check) { 						\
+	PyErr_SetString(PyECErrorObject, msg); \
+	return NULL;	}
+
+
+#ifdef BENCHMARK_ENABLED
+
+#define IS_SAME_GROUP(a, b) \
+	if(a->group->nid != b->group->nid) {	\
+		PyErr_SetString(PyECErrorObject, "mixing group elements from different curves.");	\
+		return NULL;	\
+	} 	\
+	if(strncmp((const char *) a->group->bench_id, (const char *) b->group->bench_id, ID_LEN) != 0) { \
+		PyErr_SetString(PyECErrorObject, "mixing benchmark objects not allowed.");	\
+		return NULL;	\
+	}
+
+#define IsBenchSet(obj)  obj->dBench != NULL
+
+#define Update_Op(name, op_type, elem_type, bench_obj)	\
+	Op_ ##name(op_type, elem_type, ZR, bench_obj)	\
+	Op_ ##name(op_type, elem_type, G, bench_obj)	\
+
+#define CLEAR_ALLDBENCH(bench_obj)  \
+	    CLEAR_DBENCH(bench_obj, ZR);	\
+	    CLEAR_DBENCH(bench_obj, G);
+
+#else
+
+#define IS_SAME_GROUP(a, b) \
+	if(a->group->nid != b->group->nid) {	\
+		PyErr_SetString(PyECErrorObject, "mixing group elements from different curves.");	\
+		return NULL;	\
+	}
+
+#define UPDATE_BENCH(op_type, elem_type, bench_obj)  /* ... */
+// #define UPDATE_BENCHMARK(op_type, bench_obj)  /* ... */
+#define CLEAR_ALLDBENCH(bench_obj) /* ... */
+#define GetField(count, type, group, bench_obj)  /* ... */
+
+#endif
+
+
+
+#endif

charm_lite/core/utilities/base64.c

@@ -0,0 +1,248 @@
+#include "base64.h"
+
+//
+//  NSData+Base64.m
+//  base64
+//
+//  Created by Matt Gallagher on 2009/06/03.
+//  Copyright 2009 Matt Gallagher. All rights reserved.
+//
+//  Permission is given to use this source code file, free of charge, in any
+//  project, commercial or otherwise, entirely at your risk, with the condition
+//  that any redistribution (in part or whole) of source code must retain
+//  this copyright and permission notice. Attribution in compiled projects is
+//  appreciated but not required.
+
+//
+// Mapping from 6 bit pattern to ASCII character.
+//
+static unsigned char base64EncodeLookup[65] =
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+//
+// Definition for "masked-out" areas of the base64DecodeLookup mapping
+//
+#define xx 65
+
+//
+// Mapping from ASCII character to 6 bit pattern.
+//
+static unsigned char base64DecodeLookup[256] =
+{
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 62, xx, xx, xx, 63, 
+    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, xx, xx, xx, xx, xx, xx, 
+    xx,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, xx, xx, xx, xx, xx, 
+    xx, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 
+    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+};
+
+//
+// Fundamental sizes of the binary and base64 encode/decode units in bytes
+//
+#define BINARY_UNIT_SIZE 3
+#define BASE64_UNIT_SIZE 4
+
+//
+// NewBase64Decode
+//
+// Decodes the base64 ASCII string in the inputBuffer to a newly malloced
+// output buffer.
+//
+//  inputBuffer - the source ASCII string for the decode
+//	length - the length of the string or -1 (to specify strlen should be used)
+//	outputLength - if not-NULL, on output will contain the decoded length
+//
+// returns the decoded buffer. Must be free'd by caller. Length is given by
+//	outputLength.
+//
+void *NewBase64Decode(
+					  const char *inputBuffer,
+					  size_t length,
+					  size_t *outputLength)
+{
+	if ((int) length == -1)
+	{
+		length = strlen(inputBuffer);
+	}
+	
+	size_t outputBufferSize =
+	((length+BASE64_UNIT_SIZE-1) / BASE64_UNIT_SIZE) * BINARY_UNIT_SIZE;
+	unsigned char *outputBuffer = (unsigned char *)malloc(outputBufferSize);
+	
+	size_t i = 0;
+	size_t j = 0;
+	while (i < length)
+	{
+		//
+		// Accumulate 4 valid characters (ignore everything else)
+		//
+		unsigned char accumulated[BASE64_UNIT_SIZE];
+		size_t accumulateIndex = 0;
+		while (i < length)
+		{
+			unsigned char decode = base64DecodeLookup[(unsigned char)inputBuffer[i++]];
+			if (decode != xx)
+			{
+				accumulated[accumulateIndex] = decode;
+				accumulateIndex++;
+				
+				if (accumulateIndex == BASE64_UNIT_SIZE)
+				{
+					break;
+				}
+			}
+		}
+		
+		//
+		// Store the 6 bits from each of the 4 characters as 3 bytes
+		//
+		outputBuffer[j] = (accumulated[0] << 2) | (accumulated[1] >> 4);
+		outputBuffer[j + 1] = (accumulated[1] << 4) | (accumulated[2] >> 2);
+		outputBuffer[j + 2] = (accumulated[2] << 6) | accumulated[3];
+		j += accumulateIndex - 1;
+	}
+	
+	if (outputLength)
+	{
+		*outputLength = j;
+	}
+	return outputBuffer;
+}
+
+//
+// NewBase64Decode
+//
+// Encodes the arbitrary data in the inputBuffer as base64 into a newly malloced
+// output buffer.
+//
+//  inputBuffer - the source data for the encode
+//	length - the length of the input in bytes
+//  separateLines - if zero, no CR/LF characters will be added. Otherwise
+//		a CR/LF pair will be added every 64 encoded chars.
+//	outputLength - if not-NULL, on output will contain the encoded length
+//		(not including terminating 0 char)
+//
+// returns the encoded buffer. Must be free'd by caller. Length is given by
+//	outputLength.
+//
+char *NewBase64Encode(
+					  const void *buffer,
+					  size_t length,
+					  int separateLines,
+					  size_t *outputLength)
+{
+	const unsigned char *inputBuffer = (const unsigned char *)buffer;
+	
+#define MAX_NUM_PADDING_CHARS 2
+#define OUTPUT_LINE_LENGTH 64
+#define INPUT_LINE_LENGTH ((OUTPUT_LINE_LENGTH / BASE64_UNIT_SIZE) * BINARY_UNIT_SIZE)
+#define CR_LF_SIZE 2
+	
+	//
+	// Byte accurate calculation of final buffer size
+	//
+	size_t outputBufferSize =
+	((length / BINARY_UNIT_SIZE)
+	 + ((length % BINARY_UNIT_SIZE) ? 1 : 0))
+	* BASE64_UNIT_SIZE;
+	if (separateLines)
+	{
+		outputBufferSize +=
+		(outputBufferSize / OUTPUT_LINE_LENGTH) * CR_LF_SIZE;
+	}
+	
+	//
+	// Include space for a terminating zero
+	//
+	outputBufferSize += 1;
+	
+	//
+	// Allocate the output buffer
+	//
+	char *outputBuffer = (char *)malloc(outputBufferSize);
+	if (!outputBuffer)
+	{
+		return NULL;
+	}
+	
+	size_t i = 0;
+	size_t j = 0;
+	const size_t lineLength = separateLines ? INPUT_LINE_LENGTH : length;
+	size_t lineEnd = lineLength;
+	
+	while (TRUE)
+	{
+		if (lineEnd > length)
+		{
+			lineEnd = length;
+		}
+		
+		for (; i + BINARY_UNIT_SIZE - 1 < lineEnd; i += BINARY_UNIT_SIZE)
+		{
+			//
+			// Inner loop: turn 48 bytes into 64 base64 characters
+			//
+			outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i] & 0xFC) >> 2];
+			outputBuffer[j++] = base64EncodeLookup[((inputBuffer[i] & 0x03) << 4)
+												   | ((inputBuffer[i + 1] & 0xF0) >> 4)];
+			outputBuffer[j++] = base64EncodeLookup[((inputBuffer[i + 1] & 0x0F) << 2)
+												   | ((inputBuffer[i + 2] & 0xC0) >> 6)];
+			outputBuffer[j++] = base64EncodeLookup[inputBuffer[i + 2] & 0x3F];
+		}
+		
+		if (lineEnd == length)
+		{
+			break;
+		}
+		
+		//
+		// Add the newline
+		//
+		outputBuffer[j++] = '\r';
+		outputBuffer[j++] = '\n';
+		lineEnd += lineLength;
+	}
+	
+	if (i + 1 < length)
+	{
+		//
+		// Handle the single '=' case
+		//
+		outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i] & 0xFC) >> 2];
+		outputBuffer[j++] = base64EncodeLookup[((inputBuffer[i] & 0x03) << 4)
+											   | ((inputBuffer[i + 1] & 0xF0) >> 4)];
+		outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i + 1] & 0x0F) << 2];
+		outputBuffer[j++] =	'=';
+	}
+	else if (i < length)
+	{
+		//
+		// Handle the double '=' case
+		//
+		outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i] & 0xFC) >> 2];
+		outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i] & 0x03) << 4];
+		outputBuffer[j++] = '=';
+		outputBuffer[j++] = '=';
+	}
+	outputBuffer[j] = 0;
+	
+	//
+	// Set the output length and return the buffer
+	//
+	if (outputLength)
+	{
+		*outputLength = j;
+	}
+	return outputBuffer;
+}

charm_lite/core/utilities/base64.h

@@ -0,0 +1,15 @@
+#ifndef __BASE64_H__
+#define __BASE64_H__
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define TRUE 1
+#define FALSE 0
+
+void *NewBase64Decode(const char *inputBuffer, size_t length, size_t *outputLength);
+
+char *NewBase64Encode(const void *inputBuffer, size_t length, int separateLines, size_t *outputLength);
+
+#endif

charm_lite/toolbox/PKEnc.py

@@ -0,0 +1,60 @@
+"""
+PKEnc: Public Key Encryption base class for charm-crypto-lite.
+
+This is a minimal base class for public key encryption schemes.
+Subclass this to implement your own EC-based encryption schemes.
+"""
+
+from charm_lite.toolbox.ecgroup import ECGroup
+
+__all__ = ['PKEnc']
+
+
+class PKEnc:
+    """Base class for public key encryption schemes.
+    
+    This is an empty base class that can be subclassed to implement
+    EC-based public key encryption schemes on secp256k1.
+    
+    Example:
+        from charm_lite.toolbox.PKEnc import PKEnc
+        from charm_lite.toolbox.ecgroup import ECGroup, ZR, G
+        from charm_lite.toolbox.eccurve import secp256k1
+        
+        class MyEncryptionScheme(PKEnc):
+            def __init__(self):
+                super().__init__()
+                self.group = ECGroup(secp256k1)
+            
+            def keygen(self):
+                # Generate key pair
+                x = self.group.random(ZR)  # private key
+                g = self.group.generator()
+                h = g ** x                  # public key
+                return {'pk': h, 'sk': x}
+            
+            def encrypt(self, pk, msg):
+                # Implement encryption
+                pass
+            
+            def decrypt(self, sk, ct):
+                # Implement decryption
+                pass
+    """
+    
+    def __init__(self):
+        """Initialize the PKEnc base class."""
+        pass
+    
+    def keygen(self):
+        """Generate a key pair. Override in subclass."""
+        raise NotImplementedError("keygen must be implemented by subclass")
+    
+    def encrypt(self, pk, msg):
+        """Encrypt a message. Override in subclass."""
+        raise NotImplementedError("encrypt must be implemented by subclass")
+    
+    def decrypt(self, sk, ct):
+        """Decrypt a ciphertext. Override in subclass."""
+        raise NotImplementedError("decrypt must be implemented by subclass")
+

charm_lite/toolbox/__init__.py

@@ -0,0 +1,15 @@
+# charm_lite.toolbox package
+"""
+charm-crypto-lite toolbox module.
+
+Provides minimal EC operations on secp256k1:
+- ECGroup: Elliptic curve group abstraction
+- PKEnc: Base class for public key encryption schemes
+- secp256k1: Curve constant
+"""
+
+from charm_lite.toolbox.ecgroup import ECGroup, ZR, G, ec_element
+from charm_lite.toolbox.eccurve import secp256k1
+from charm_lite.toolbox.PKEnc import PKEnc
+
+__all__ = ['ECGroup', 'ZR', 'G', 'ec_element', 'secp256k1', 'PKEnc']

charm_lite/toolbox/eccurve.py

@@ -0,0 +1,12 @@
+"""
+secp256k1 curve constant for charm-crypto-lite.
+
+This is the only curve supported by charm-crypto-lite.
+For additional curves, use the full charm-crypto-framework package.
+"""
+
+# secp256k1: The curve used by Bitcoin and Ethereum
+# OpenSSL NID (Numeric ID) for secp256k1
+secp256k1 = 714
+
+__all__ = ['secp256k1']