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

charm/core/crypto/cryptobase/block_template.h

@@ -0,0 +1,69 @@
+
+
+#ifndef BLOCK_TEMPLATE_H
+#define BLOCK_TEMPLATE_H
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef _HAVE_STDC_HEADERS
+#include <string.h>
+#endif
+
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif
+
+#include <Python.h>
+#include <structmember.h>
+#include "modsupport.h"
+#include "_counter.h"
+
+/* Python 3.14+ compatibility - PyUnicode_GET_SIZE was removed */
+#if PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 14
+#define PyUnicode_GET_SIZE(o) PyUnicode_GetLength(o)
+#endif
+
+#define TRUE	1
+#define FALSE	0
+
+/* Cipher operation modes */
+#define MODE_ECB 1
+#define MODE_CBC 2
+#define MODE_CFB 3
+#define MODE_PGP 4
+#define MODE_OFB 5
+#define MODE_CTR 6
+
+#define _STR(x) #x
+#define _XSTR(x) _STR(x)
+#define _PASTE(x,y) x##y
+#define _PASTE2(x,y) _PASTE(x,y)
+#define _MODULE_STRING _XSTR(MODULE_NAME)
+
+#if PY_MAJOR_VERSION >= 3
+#define _MODULE_NAME _PASTE2(PyInit_, MODULE_NAME)
+#else
+#define _MODULE_NAME _PASTE2(init,MODULE_NAME)
+#endif
+
+typedef struct
+{
+	PyObject_HEAD
+	Py_ssize_t mode, count, segment_size, prf_mode;
+	unsigned char IV[BLOCK_SIZE], oldCipher[BLOCK_SIZE];
+	PyObject *counter;
+	int counter_shortcut;
+	block_state st;
+} ALGobject;
+
+// staticforward PyTypeObject ALGtype;
+static PyTypeObject ALGtype;
+
+#define is_ALGobject(v)		((v)->ob_type == &ALGtype)
+
+PyMemberDef ALGmembers[];
+PyMethodDef ALGmethods[];
+
+#endif

charm/core/crypto/cryptobase/cryptobasemodule.c

@@ -0,0 +1,220 @@
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif
+#include <Python.h>
+#include <structmember.h>
+
+static PyTypeObject BaseType;
+static PyObject *BaseError;
+#define PyBase_Check(obj) PyObject_TypeCheck(obj, &BaseType)
+#define TRUE	1
+#define FALSE	0
+#define PKG  "charm.core.crypto."
+enum MOP {NONE = 0, MODE_ECB, MODE_CBC, MODE_CFB, MODE_PGP, MODE_OFB, MODE_CTR};
+enum ALG {AES, DES, DES3};
+
+typedef struct {
+	PyObject_HEAD
+	int initialized;
+} Base;
+
+// define functions here
+/* Description: an example of inputs cryptobase.selectPRF(AES, ('This is a key 456', MODE_ECB))
+ *
+ */
+static PyObject *selectPRF(Base *self, PyObject *args) {
+	PyObject *tuple, *module, *module_dict, *new_func, *prf;
+	int alg;
+	char *ALG = NULL;
+
+	if(!PyArg_ParseTuple(args, "iO", &alg, &tuple)) {
+		PyErr_SetString(BaseError, "1st argument is algorithm and 2nd is tuple of arguments.");
+		return NULL;
+	}
+
+	switch(alg) {
+		case AES: ALG = PKG"AES"; break;
+		case DES: ALG = PKG"DES"; break;
+		case DES3: ALG = PKG"DES3"; break;
+		default: ALG = PKG"AES"; break; /* default */
+	}
+
+	module = PyImport_ImportModule(ALG);
+	if (!module) {
+		Py_XDECREF (module);
+		return NULL;
+	}
+	// printf("module ptr => %p\n", module);
+	module_dict = PyModule_GetDict (module);
+	Py_DECREF (module);
+	new_func = PyDict_GetItemString(module_dict, "new");
+	// printf("new_func ptr => %p\n", new_func);
+	if (!PyCallable_Check(new_func))
+	{
+		PyErr_SetString(BaseError, "ALG.new is not callable.");
+		return NULL;
+	}
+	prf = PyObject_CallObject(new_func, tuple);
+	PyObject *ret = PyObject_CallMethod(prf, "setMode", "i", TRUE);
+	if(ret == NULL) {
+		// return error
+		PyErr_SetString(BaseError, "Could not call setMode on ALG object.");
+		Py_DECREF(prf);
+		return NULL;
+	}
+	Py_DECREF(ret);
+	return prf;
+}
+
+static PyObject *selectPRP(Base *self, PyObject *args) {
+	PyObject *tuple, *module, *module_dict, *new_func, *prp;
+	int alg;
+	char *ALG = NULL;
+
+	if(!PyArg_ParseTuple(args, "iO", &alg, &tuple)) {
+		PyErr_SetString(BaseError, "1st argument is algorithm and 2nd is tuple of arguments.");
+		return NULL;
+	}
+
+	switch(alg) {
+		case AES: ALG = PKG"AES"; break;
+		case DES: ALG = PKG"DES"; break;
+		case DES3: ALG = PKG"DES3"; break;
+		default: ALG = PKG"AES"; break; /* default */
+	}
+
+	module = PyImport_ImportModule(ALG);
+	if (!module) {
+		Py_XDECREF (module);
+		return NULL;
+	}
+	module_dict = PyModule_GetDict (module);
+	Py_DECREF (module);
+	new_func = PyDict_GetItemString(module_dict, "new");
+
+	if (!PyCallable_Check(new_func))
+	{
+		PyErr_SetString(BaseError, "ALG.new is not callable.");
+		return NULL;
+	}
+	prp = PyObject_CallObject(new_func, tuple);
+	return prp;
+}
+
+//static PyObject *selectHash(Base *self, PyObject *args) {
+//	return NULL;
+//}
+
+static PyTypeObject BaseType = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+    "crypto.Base",             /*tp_name*/
+    sizeof(Base),             /*tp_basicsize*/
+    0,                         /*tp_itemsize*/
+    0, 						   /*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, // (ternaryfunc) Base_call, /*tp_call*/
+    0, // (reprfunc) Base_print,   /*tp_str*/
+    0,                         /*tp_getattro*/
+    0,                         /*tp_setattro*/
+    0,                         /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT, 	   /*tp_flags*/
+    "Crypto Base modular objects",    /* tp_doc */
+};
+
+struct module_state {
+	PyObject *error;
+};
+
+#if PY_MAJOR_VERSION >= 3
+#define GETSTATE(m) ((struct module_state *) PyModule_GetState(m))
+#else
+#define GETSTATE(m) (&_state)
+static struct module_state _state;
+#endif
+
+static PyMethodDef module_methods[] = {
+	{"selectPRF", (PyCFunction)selectPRF, METH_VARARGS, "selects a Pseudo-random Function given specific requirements."},
+	{"selectPRP", (PyCFunction)selectPRP, METH_VARARGS, "selects a Pseudo-random Permutation given specific requirements."},
+	// may need adapter functions here as well?
+	{NULL}
+};
+
+#if PY_MAJOR_VERSION >= 3
+static int base_traverse(PyObject *m, visitproc visit, void *arg) {
+	Py_VISIT(GETSTATE(m)->error);
+	return 0;
+}
+
+static int base_clear(PyObject *m) {
+	Py_CLEAR(GETSTATE(m)->error);
+    Py_XDECREF(BaseError);
+	return 0;
+}
+
+static struct PyModuleDef moduledef = {
+		PyModuleDef_HEAD_INIT,
+		"cryptobase",
+		NULL,
+		sizeof(struct module_state),
+		module_methods,
+		NULL,
+		base_traverse,
+		base_clear,
+		NULL
+};
+
+#define INITERROR return NULL
+PyMODINIT_FUNC
+PyInit_cryptobase(void) 		{
+#else
+#define INITERROR return
+void initcryptobase(void) 		{
+#endif
+	PyObject *m;
+    if(PyType_Ready(&BaseType) < 0) INITERROR;
+
+    // initialize module
+#if PY_MAJOR_VERSION >= 3
+	m = PyModule_Create(&moduledef);
+#else
+	m = Py_InitModule("cryptobase", module_methods);
+#endif
+	// add integer type to module
+	if(m == NULL) INITERROR;
+	Py_INCREF(&BaseType);
+    PyModule_AddObject(m, "cryptobase", (PyObject *)&BaseType);
+    // algorithms
+    PyModule_AddIntConstant(m, "AES", AES);
+    PyModule_AddIntConstant(m, "DES", DES);
+    PyModule_AddIntConstant(m, "DES3", DES3);
+
+    // mode of operation
+	PyModule_AddIntConstant(m, "MODE_ECB", MODE_ECB);
+	PyModule_AddIntConstant(m, "MODE_CBC", MODE_CBC);
+	PyModule_AddIntConstant(m, "MODE_CFB", MODE_CFB);
+	PyModule_AddIntConstant(m, "MODE_PGP", MODE_PGP);
+	PyModule_AddIntConstant(m, "MODE_OFB", MODE_OFB);
+	PyModule_AddIntConstant(m, "MODE_CTR", MODE_CTR);
+
+	// add integer error to module
+	struct module_state *st = GETSTATE(m);
+	st->error = PyErr_NewException("base.Error", NULL, NULL);
+	if(st->error == NULL) {
+		Py_DECREF(m);
+		INITERROR;
+	}
+    BaseError = st->error;
+    Py_INCREF(BaseError);
+//    PyModule_AddObject(m, "base.error", BaseError);
+#if PY_MAJOR_VERSION >= 3
+	return m;
+#endif
+}

charm/core/crypto/cryptobase/libtom/tomcrypt.h

@@ -0,0 +1,90 @@
+#ifndef TOMCRYPT_H_
+#define TOMCRYPT_H_
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <time.h>
+#include <ctype.h>
+#include <limits.h>
+
+/* use configuration data */
+#include <tomcrypt_custom.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* version */
+#define CRYPT   0x0117
+#define SCRYPT  "1.17"
+
+/* max size of either a cipher/hash block or symmetric key [largest of the two] */
+#define MAXBLOCKSIZE  128
+
+/* descriptor table size */
+#define TAB_SIZE      32
+
+/* error codes [will be expanded in future releases] */
+enum {
+   CRYPT_OK=0,             /* Result OK */
+   CRYPT_ERROR,            /* Generic Error */
+   CRYPT_NOP,              /* Not a failure but no operation was performed */
+
+   CRYPT_INVALID_KEYSIZE,  /* Invalid key size given */
+   CRYPT_INVALID_ROUNDS,   /* Invalid number of rounds */
+   CRYPT_FAIL_TESTVECTOR,  /* Algorithm failed test vectors */
+
+   CRYPT_BUFFER_OVERFLOW,  /* Not enough space for output */
+   CRYPT_INVALID_PACKET,   /* Invalid input packet given */
+
+   CRYPT_INVALID_PRNGSIZE, /* Invalid number of bits for a PRNG */
+   CRYPT_ERROR_READPRNG,   /* Could not read enough from PRNG */
+
+   CRYPT_INVALID_CIPHER,   /* Invalid cipher specified */
+   CRYPT_INVALID_HASH,     /* Invalid hash specified */
+   CRYPT_INVALID_PRNG,     /* Invalid PRNG specified */
+
+   CRYPT_MEM,              /* Out of memory */
+
+   CRYPT_PK_TYPE_MISMATCH, /* Not equivalent types of PK keys */
+   CRYPT_PK_NOT_PRIVATE,   /* Requires a private PK key */
+
+   CRYPT_INVALID_ARG,      /* Generic invalid argument */
+   CRYPT_FILE_NOTFOUND,    /* File Not Found */
+
+   CRYPT_PK_INVALID_TYPE,  /* Invalid type of PK key */
+   CRYPT_PK_INVALID_SYSTEM,/* Invalid PK system specified */
+   CRYPT_PK_DUP,           /* Duplicate key already in key ring */
+   CRYPT_PK_NOT_FOUND,     /* Key not found in keyring */
+   CRYPT_PK_INVALID_SIZE,  /* Invalid size input for PK parameters */
+
+   CRYPT_INVALID_PRIME_SIZE,/* Invalid size of prime requested */
+   CRYPT_PK_INVALID_PADDING, /* Invalid padding on input */
+
+   CRYPT_HASH_OVERFLOW      /* Hash applied to too many bits */
+};
+
+#include <tomcrypt_cfg.h>
+#include <tomcrypt_macros.h>
+#include <tomcrypt_cipher.h>
+#include <tomcrypt_hash.h>
+#include <tomcrypt_mac.h>
+#include <tomcrypt_prng.h>
+#include <tomcrypt_pk.h>
+#include <tomcrypt_math.h>
+#include <tomcrypt_misc.h>
+#include <tomcrypt_argchk.h>
+#include <tomcrypt_pkcs.h>
+
+#ifdef __cplusplus
+   }
+#endif
+
+#endif /* TOMCRYPT_H_ */
+
+
+/* $Source$ */
+/* $Revision$ */
+/* $Date$ */

charm/core/crypto/cryptobase/libtom/tomcrypt_argchk.h

@@ -0,0 +1,44 @@
+/* Defines the LTC_ARGCHK macro used within the library */
+/* ARGTYPE is defined in tomcrypt_cfg.h */
+#if ARGTYPE == 0
+
+#include <signal.h>
+
+/* this is the default LibTomCrypt macro  */
+#if defined(__clang__) || defined(__GNUC_MINOR__)
+#define NORETURN __attribute__ ((noreturn))
+#else
+#define NORETURN
+#endif
+
+void crypt_argchk(char *v, char *s, int d) NORETURN;
+#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0)
+#define LTC_ARGCHKVD(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0)
+
+#elif ARGTYPE == 1
+
+/* fatal type of error */
+#define LTC_ARGCHK(x) assert((x))
+#define LTC_ARGCHKVD(x) LTC_ARGCHK(x)
+
+#elif ARGTYPE == 2
+
+#define LTC_ARGCHK(x) if (!(x)) { fprintf(stderr, "\nwarning: ARGCHK failed at %s:%d\n", __FILE__, __LINE__); }
+#define LTC_ARGCHKVD(x) LTC_ARGCHK(x)
+
+#elif ARGTYPE == 3
+
+#define LTC_ARGCHK(x)
+#define LTC_ARGCHKVD(x) LTC_ARGCHK(x)
+
+#elif ARGTYPE == 4
+
+#define LTC_ARGCHK(x)   if (!(x)) return CRYPT_INVALID_ARG;
+#define LTC_ARGCHKVD(x) if (!(x)) return;
+
+#endif
+
+
+/* $Source$ */
+/* $Revision$ */
+/* $Date$ */

charm/core/crypto/cryptobase/libtom/tomcrypt_cfg.h

@@ -0,0 +1,186 @@
+/* This is the build config file.
+ *
+ * With this you can setup what to inlcude/exclude automatically during any build.  Just comment
+ * out the line that #define's the word for the thing you want to remove.  phew!
+ */
+
+#ifndef TOMCRYPT_CFG_H
+#define TOMCRYPT_CFG_H
+
+#if defined(_WIN32) || defined(_MSC_VER)
+#define LTC_CALL __cdecl
+#else
+#ifndef LTC_CALL
+   #define LTC_CALL
+#endif
+#endif
+
+#ifndef LTC_EXPORT
+#define LTC_EXPORT
+#endif
+
+/* certain platforms use macros for these, making the prototypes broken */
+#ifndef LTC_NO_PROTOTYPES
+
+/* you can change how memory allocation works ... */
+LTC_EXPORT void * LTC_CALL XMALLOC(size_t n);
+LTC_EXPORT void * LTC_CALL XREALLOC(void *p, size_t n);
+LTC_EXPORT void * LTC_CALL XCALLOC(size_t n, size_t s);
+LTC_EXPORT void LTC_CALL XFREE(void *p);
+
+LTC_EXPORT void LTC_CALL XQSORT(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));
+
+
+/* change the clock function too */
+LTC_EXPORT clock_t LTC_CALL XCLOCK(void);
+
+/* various other functions */
+LTC_EXPORT void * LTC_CALL XMEMCPY(void *dest, const void *src, size_t n);
+LTC_EXPORT int   LTC_CALL XMEMCMP(const void *s1, const void *s2, size_t n);
+LTC_EXPORT void * LTC_CALL XMEMSET(void *s, int c, size_t n);
+
+LTC_EXPORT int   LTC_CALL XSTRCMP(const char *s1, const char *s2);
+
+#endif
+
+/* type of argument checking, 0=default, 1=fatal and 2=error+continue, 3=nothing */
+#ifndef ARGTYPE
+   #define ARGTYPE  0
+#endif
+
+/* Controls endianess and size of registers.  Leave uncommented to get platform neutral [slower] code
+ *
+ * Note: in order to use the optimized macros your platform must support unaligned 32 and 64 bit read/writes.
+ * The x86 platforms allow this but some others [ARM for instance] do not.  On those platforms you **MUST**
+ * use the portable [slower] macros.
+ */
+
+/* detect x86-32 machines somewhat */
+#if !defined(__STRICT_ANSI__) && !defined(__x86_64__) && !defined(_WIN64) && ((defined(_MSC_VER) && defined(WIN32)) || (defined(__GNUC__) && (defined(__DJGPP__) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__i386__))))
+   #define ENDIAN_LITTLE
+   #define ENDIAN_32BITWORD
+   #define LTC_FAST
+#endif
+
+/* detects MIPS R5900 processors (PS2) */
+#if (defined(__R5900) || defined(R5900) || defined(__R5900__)) && (defined(_mips) || defined(__mips__) || defined(mips))
+   #define ENDIAN_LITTLE
+   #define ENDIAN_64BITWORD
+#endif
+
+/* detect amd64 */
+#if !defined(__STRICT_ANSI__) && defined(__x86_64__)
+   #define ENDIAN_LITTLE
+   #define ENDIAN_64BITWORD
+   #define LTC_FAST
+#endif
+
+/* detect PPC32 */
+#if !defined(__STRICT_ANSI__) && defined(LTC_PPC32)
+   #define ENDIAN_BIG
+   #define ENDIAN_32BITWORD
+   #define LTC_FAST
+#endif
+
+/* fix for MSVC ...evil! */
+#ifdef _MSC_VER
+   #define CONST64(n) n ## ui64
+   typedef unsigned __int64 ulong64;
+#else
+   #define CONST64(n) n ## ULL
+   typedef unsigned long long ulong64;
+#endif
+
+/* this is the "32-bit at least" data type
+ * Re-define it to suit your platform but it must be at least 32-bits
+ */
+#if defined(__x86_64__) || (defined(__sparc__) && defined(__arch64__))
+   typedef unsigned ulong32;
+#else
+   typedef unsigned long ulong32;
+#endif
+
+#ifdef LTC_NO_FAST
+   #undef LTC_FAST
+#endif
+
+#ifdef LTC_FAST
+#if __GNUC__ < 4 /* if the compiler does not support gnu extensions, i.e. its neither clang nor gcc nor icc */
+#error the LTC_FAST hack is only available on compilers that support __attribute__((may_alias)) - disable it for your compiler, and dont worry, it won`t buy you much anyway
+#else
+#ifdef ENDIAN_64BITWORD
+typedef ulong64 __attribute__((__may_alias__)) LTC_FAST_TYPE;
+#else
+typedef ulong32 __attribute__((__may_alias__)) LTC_FAST_TYPE;
+#endif
+#endif
+#endif /* LTC_FAST */
+
+/* detect sparc and sparc64 */
+#if defined(__sparc__)
+  #define ENDIAN_BIG
+  #if defined(__arch64__)
+    #define ENDIAN_64BITWORD
+  #else
+    #define ENDIAN_32BITWORD
+  #endif
+#endif
+
+#ifdef ENDIAN_64BITWORD
+typedef ulong64 ltc_mp_digit;
+#else
+typedef ulong32 ltc_mp_digit;
+#endif
+
+/* No asm is a quick way to disable anything "not portable" */
+#ifdef LTC_NO_ASM
+   #undef ENDIAN_LITTLE
+   #undef ENDIAN_BIG
+   #undef ENDIAN_32BITWORD
+   #undef ENDIAN_64BITWORD
+   #undef LTC_FAST
+   #undef LTC_FAST_TYPE
+   #define LTC_NO_ROLC
+   #define LTC_NO_BSWAP
+#endif
+
+/* #define ENDIAN_LITTLE */
+/* #define ENDIAN_BIG */
+
+/* #define ENDIAN_32BITWORD */
+/* #define ENDIAN_64BITWORD */
+
+#if (defined(ENDIAN_BIG) || defined(ENDIAN_LITTLE)) && !(defined(ENDIAN_32BITWORD) || defined(ENDIAN_64BITWORD))
+    #error You must specify a word size as well as endianess in tomcrypt_cfg.h
+#endif
+
+#if !(defined(ENDIAN_BIG) || defined(ENDIAN_LITTLE))
+   #define ENDIAN_NEUTRAL
+#endif
+
+#if (defined(ENDIAN_32BITWORD) && defined(ENDIAN_64BITWORD))
+    #error Can not be 32 and 64 bit words...
+#endif
+
+/* gcc 4.3 and up has a bswap builtin; detect it by gcc version.
+ * clang also supports the bswap builtin, and although clang pretends
+ * to be gcc (macro-wise, anyway), clang pretends to be a version
+ * prior to gcc 4.3, so we can't detect bswap that way.  Instead,
+ * clang has a __has_builtin mechanism that can be used to check
+ * for builtins:
+ * http://clang.llvm.org/docs/LanguageExtensions.html#feature_check */
+#ifndef __has_builtin
+   #define __has_builtin(x) 0
+#endif
+#if !defined(LTC_NO_BSWAP) && defined(__GNUC__) &&                      \
+   ((__GNUC__ * 100 + __GNUC_MINOR__ >= 403) ||                         \
+    (__has_builtin(__builtin_bswap32) && __has_builtin(__builtin_bswap64)))
+   #define LTC_HAVE_BSWAP_BUILTIN
+#endif
+
+#endif
+
+
+/* $Source$ */
+/* $Revision$ */
+/* $Date$ */