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

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

@@ -0,0 +1,90 @@
+/* PKCS Header Info */
+
+/* ===> PKCS #1 -- RSA Cryptography <=== */
+#ifdef LTC_PKCS_1
+
+enum ltc_pkcs_1_v1_5_blocks
+{
+  LTC_PKCS_1_EMSA   = 1,        /* Block type 1 (PKCS #1 v1.5 signature padding) */
+  LTC_PKCS_1_EME    = 2         /* Block type 2 (PKCS #1 v1.5 encryption padding) */
+};
+
+enum ltc_pkcs_1_paddings
+{
+  LTC_PKCS_1_V1_5     = 1,        /* PKCS #1 v1.5 padding (\sa ltc_pkcs_1_v1_5_blocks) */
+  LTC_PKCS_1_OAEP     = 2,        /* PKCS #1 v2.0 encryption padding */
+  LTC_PKCS_1_PSS      = 3         /* PKCS #1 v2.1 signature padding */
+};
+
+int pkcs_1_mgf1(      int            hash_idx,
+                const unsigned char *seed, unsigned long seedlen,
+                      unsigned char *mask, unsigned long masklen);
+
+int pkcs_1_i2osp(void *n, unsigned long modulus_len, unsigned char *out);
+int pkcs_1_os2ip(void *n, unsigned char *in, unsigned long inlen);
+
+/* *** v1.5 padding */
+int pkcs_1_v1_5_encode(const unsigned char *msg,
+                             unsigned long  msglen,
+                             int            block_type,
+                             unsigned long  modulus_bitlen,
+                                prng_state *prng,
+                                       int  prng_idx,
+                             unsigned char *out,
+                             unsigned long *outlen);
+
+int pkcs_1_v1_5_decode(const unsigned char *msg,
+                             unsigned long  msglen,
+                                       int  block_type,
+                             unsigned long  modulus_bitlen,
+                             unsigned char *out,
+                             unsigned long *outlen,
+                                       int *is_valid);
+
+/* *** v2.1 padding */
+int pkcs_1_oaep_encode(const unsigned char *msg,    unsigned long msglen,
+                       const unsigned char *lparam, unsigned long lparamlen,
+                             unsigned long modulus_bitlen, prng_state *prng,
+                             int           prng_idx,         int  hash_idx,
+                             unsigned char *out,    unsigned long *outlen);
+
+int pkcs_1_oaep_decode(const unsigned char *msg,    unsigned long msglen,
+                       const unsigned char *lparam, unsigned long lparamlen,
+                             unsigned long modulus_bitlen, int hash_idx,
+                             unsigned char *out,    unsigned long *outlen,
+                             int           *res);
+
+int pkcs_1_pss_encode(const unsigned char *msghash, unsigned long msghashlen,
+                            unsigned long saltlen,  prng_state   *prng,
+                            int           prng_idx, int           hash_idx,
+                            unsigned long modulus_bitlen,
+                            unsigned char *out,     unsigned long *outlen);
+
+int pkcs_1_pss_decode(const unsigned char *msghash, unsigned long msghashlen,
+                      const unsigned char *sig,     unsigned long siglen,
+                            unsigned long saltlen,  int           hash_idx,
+                            unsigned long modulus_bitlen, int    *res);
+
+#endif /* LTC_PKCS_1 */
+
+/* ===> PKCS #5 -- Password Based Cryptography <=== */
+#ifdef LTC_PKCS_5
+
+/* Algorithm #1 (old) */
+int pkcs_5_alg1(const unsigned char *password, unsigned long password_len,
+                const unsigned char *salt,
+                int iteration_count,  int hash_idx,
+                unsigned char *out,   unsigned long *outlen);
+
+/* Algorithm #2 (new) */
+int pkcs_5_alg2(const unsigned char *password, unsigned long password_len,
+                const unsigned char *salt,     unsigned long salt_len,
+                int iteration_count,           int hash_idx,
+                unsigned char *out,            unsigned long *outlen);
+
+int pkcs_5_test (void);
+#endif  /* LTC_PKCS_5 */
+
+/* $Source$ */
+/* $Revision$ */
+/* $Date$ */

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

@@ -0,0 +1,199 @@
+/* ---- PRNG Stuff ---- */
+#ifdef LTC_YARROW
+struct yarrow_prng {
+    int                   cipher, hash;
+    unsigned char         pool[MAXBLOCKSIZE];
+    symmetric_CTR         ctr;
+    LTC_MUTEX_TYPE(prng_lock)
+};
+#endif
+
+#ifdef LTC_RC4
+struct rc4_prng {
+    int x, y;
+    unsigned char buf[256];
+};
+#endif
+
+#ifdef LTC_FORTUNA
+struct fortuna_prng {
+    hash_state pool[LTC_FORTUNA_POOLS];     /* the  pools */
+
+    symmetric_key skey;
+
+    unsigned char K[32],      /* the current key */
+                  IV[16];     /* IV for CTR mode */
+
+    unsigned long pool_idx,   /* current pool we will add to */
+                  pool0_len,  /* length of 0'th pool */
+                  wd;
+
+    ulong64       reset_cnt;  /* number of times we have reset */
+    LTC_MUTEX_TYPE(prng_lock)
+};
+#endif
+
+#ifdef LTC_SOBER128
+struct sober128_prng {
+    ulong32      R[17],          /* Working storage for the shift register */
+                 initR[17],      /* saved register contents */
+                 konst,          /* key dependent constant */
+                 sbuf;           /* partial word encryption buffer */
+
+    int          nbuf,           /* number of part-word stream bits buffered */
+                 flag,           /* first add_entropy call or not? */
+                 set;            /* did we call add_entropy to set key? */
+
+};
+#endif
+
+typedef union Prng_state {
+    char dummy[1];
+#ifdef LTC_YARROW
+    struct yarrow_prng    yarrow;
+#endif
+#ifdef LTC_RC4
+    struct rc4_prng       rc4;
+#endif
+#ifdef LTC_FORTUNA
+    struct fortuna_prng   fortuna;
+#endif
+#ifdef LTC_SOBER128
+    struct sober128_prng  sober128;
+#endif
+} prng_state;
+
+/** PRNG descriptor */
+extern struct ltc_prng_descriptor {
+    /** Name of the PRNG */
+    char *name;
+    /** size in bytes of exported state */
+    int  export_size;
+    /** Start a PRNG state
+        @param prng   [out] The state to initialize
+        @return CRYPT_OK if successful
+    */
+    int (*start)(prng_state *prng);
+    /** Add entropy to the PRNG
+        @param in         The entropy
+        @param inlen      Length of the entropy (octets)\
+        @param prng       The PRNG state
+        @return CRYPT_OK if successful
+    */
+    int (*add_entropy)(const unsigned char *in, unsigned long inlen, prng_state *prng);
+    /** Ready a PRNG state to read from
+        @param prng       The PRNG state to ready
+        @return CRYPT_OK if successful
+    */
+    int (*ready)(prng_state *prng);
+    /** Read from the PRNG
+        @param out     [out] Where to store the data
+        @param outlen  Length of data desired (octets)
+        @param prng    The PRNG state to read from
+        @return Number of octets read
+    */
+    unsigned long (*read)(unsigned char *out, unsigned long outlen, prng_state *prng);
+    /** Terminate a PRNG state
+        @param prng   The PRNG state to terminate
+        @return CRYPT_OK if successful
+    */
+    int (*done)(prng_state *prng);
+    /** Export a PRNG state
+        @param out     [out] The destination for the state
+        @param outlen  [in/out] The max size and resulting size of the PRNG state
+        @param prng    The PRNG to export
+        @return CRYPT_OK if successful
+    */
+    int (*pexport)(unsigned char *out, unsigned long *outlen, prng_state *prng);
+    /** Import a PRNG state
+        @param in      The data to import
+        @param inlen   The length of the data to import (octets)
+        @param prng    The PRNG to initialize/import
+        @return CRYPT_OK if successful
+    */
+    int (*pimport)(const unsigned char *in, unsigned long inlen, prng_state *prng);
+    /** Self-test the PRNG
+        @return CRYPT_OK if successful, CRYPT_NOP if self-testing has been disabled
+    */
+    int (*test)(void);
+} prng_descriptor[];
+
+#ifdef LTC_YARROW
+int yarrow_start(prng_state *prng);
+int yarrow_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng);
+int yarrow_ready(prng_state *prng);
+unsigned long yarrow_read(unsigned char *out, unsigned long outlen, prng_state *prng);
+int yarrow_done(prng_state *prng);
+int  yarrow_export(unsigned char *out, unsigned long *outlen, prng_state *prng);
+int  yarrow_import(const unsigned char *in, unsigned long inlen, prng_state *prng);
+int  yarrow_test(void);
+extern const struct ltc_prng_descriptor yarrow_desc;
+#endif
+
+#ifdef LTC_FORTUNA
+int fortuna_start(prng_state *prng);
+int fortuna_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng);
+int fortuna_ready(prng_state *prng);
+unsigned long fortuna_read(unsigned char *out, unsigned long outlen, prng_state *prng);
+int fortuna_done(prng_state *prng);
+int  fortuna_export(unsigned char *out, unsigned long *outlen, prng_state *prng);
+int  fortuna_import(const unsigned char *in, unsigned long inlen, prng_state *prng);
+int  fortuna_test(void);
+extern const struct ltc_prng_descriptor fortuna_desc;
+#endif
+
+#ifdef LTC_RC4
+int rc4_start(prng_state *prng);
+int rc4_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng);
+int rc4_ready(prng_state *prng);
+unsigned long rc4_read(unsigned char *out, unsigned long outlen, prng_state *prng);
+int  rc4_done(prng_state *prng);
+int  rc4_export(unsigned char *out, unsigned long *outlen, prng_state *prng);
+int  rc4_import(const unsigned char *in, unsigned long inlen, prng_state *prng);
+int  rc4_test(void);
+extern const struct ltc_prng_descriptor rc4_desc;
+#endif
+
+#ifdef LTC_SPRNG
+int sprng_start(prng_state *prng);
+int sprng_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng);
+int sprng_ready(prng_state *prng);
+unsigned long sprng_read(unsigned char *out, unsigned long outlen, prng_state *prng);
+int sprng_done(prng_state *prng);
+int  sprng_export(unsigned char *out, unsigned long *outlen, prng_state *prng);
+int  sprng_import(const unsigned char *in, unsigned long inlen, prng_state *prng);
+int  sprng_test(void);
+extern const struct ltc_prng_descriptor sprng_desc;
+#endif
+
+#ifdef LTC_SOBER128
+int sober128_start(prng_state *prng);
+int sober128_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng);
+int sober128_ready(prng_state *prng);
+unsigned long sober128_read(unsigned char *out, unsigned long outlen, prng_state *prng);
+int sober128_done(prng_state *prng);
+int  sober128_export(unsigned char *out, unsigned long *outlen, prng_state *prng);
+int  sober128_import(const unsigned char *in, unsigned long inlen, prng_state *prng);
+int  sober128_test(void);
+extern const struct ltc_prng_descriptor sober128_desc;
+#endif
+
+int find_prng(const char *name);
+int register_prng(const struct ltc_prng_descriptor *prng);
+int unregister_prng(const struct ltc_prng_descriptor *prng);
+int prng_is_valid(int idx);
+LTC_MUTEX_PROTO(ltc_prng_mutex)
+
+/* Slow RNG you **might** be able to use to seed a PRNG with.  Be careful as this
+ * might not work on all platforms as planned
+ */
+unsigned long rng_get_bytes(unsigned char *out,
+                            unsigned long outlen,
+                            void (*callback)(void));
+
+int rng_make_prng(int bits, int wprng, prng_state *prng, void (*callback)(void));
+
+
+/* $Source$ */
+/* $Revision$ */
+/* $Date$ */

charm/core/crypto/cryptobase/stream_template.c

@@ -0,0 +1,271 @@
+/* -*- C -*- */
+
+/*
+ *  stream_template.c : Generic framework for stream ciphers
+ *
+ * Written by Andrew Kuchling and others
+ *
+ * ===================================================================
+ * The contents of this file are dedicated to the public domain.  To
+ * the extent that dedication to the public domain is not available,
+ * everyone is granted a worldwide, perpetual, royalty-free,
+ * non-exclusive license to exercise all rights associated with the
+ * contents of this file for any purpose whatsoever.
+ * No rights are reserved.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * ===================================================================
+ */
+
+
+#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 "modsupport.h"
+
+#define _STR(x) #x
+#define _XSTR(x) _STR(x)
+#define _PASTE(x,y) x##y
+#define _PASTE2(x,y) _PASTE(x,y)
+#define _MODULE_NAME _PASTE2(init,MODULE_NAME)
+#define _MODULE_STRING _XSTR(MODULE_NAME)
+
+        /*
+	 *
+	 * Python interface
+	 *
+	 */
+
+typedef struct 
+{
+	PyObject_HEAD 
+	stream_state st;
+} ALGobject;
+
+staticforward PyTypeObject ALGtype;
+
+#define is_ALGobject(v)		((v)->ob_type == &ALGtype)
+
+static ALGobject *
+newALGobject(void)
+{
+	ALGobject * new;
+	new = PyObject_New(ALGobject, &ALGtype);
+	return new;
+}
+
+static void
+ALGdealloc(PyObject *ptr)
+{
+	ALGobject *self = (ALGobject *)ptr;
+
+	/* Overwrite the contents of the object */
+	memset((char*)&(self->st), 0, sizeof(stream_state));
+	PyObject_Del(ptr);
+}
+
+static char ALGnew__doc__[] = 
+"Return a new " _MODULE_STRING " encryption object.";
+
+static char *kwlist[] = {"key", NULL};
+
+static ALGobject *
+ALGnew(PyObject *self, PyObject *args, PyObject *kwdict)
+{
+	unsigned char *key;
+	ALGobject * new;
+	Py_ssize_t keylen;
+
+	new = newALGobject();
+	if (!PyArg_ParseTupleAndKeywords(args, kwdict, "s#", kwlist,
+					 &key, &keylen))
+	{
+		Py_DECREF(new);
+		return NULL;
+	}
+
+	if (KEY_SIZE!=0 && keylen != KEY_SIZE)
+	{
+		PyErr_SetString(PyExc_ValueError,
+				_MODULE_STRING " key must be "
+				"KEY_SIZE bytes long");
+		return NULL;
+	}
+	if (KEY_SIZE== 0 && keylen == 0)
+	{
+		PyErr_SetString(PyExc_ValueError,
+				_MODULE_STRING " key cannot be "
+				"the null string (0 bytes long)");
+		return NULL;
+	}
+	stream_init(&(new->st), key, (int) keylen);
+	if (PyErr_Occurred())
+	{
+		Py_DECREF(new);
+		return NULL;
+	}
+	return new;
+}
+
+static char ALG_Encrypt__doc__[] =
+"Decrypt the provided string of binary data.";
+
+static PyObject *
+ALG_Encrypt(ALGobject *self, PyObject *args)
+{
+	unsigned char *buffer, *str;
+	Py_ssize_t len;
+	PyObject *result;
+
+	if (!PyArg_Parse(args, "s#", &str, &len))
+		return NULL;
+	if (len == 0)			/* Handle empty string */
+	{
+		return PyString_FromStringAndSize(NULL, 0);
+	}
+	buffer = malloc(len);
+	if (buffer == NULL)
+	{
+		PyErr_SetString(PyExc_MemoryError, "No memory available in "
+				_MODULE_STRING " encrypt");
+		return NULL;
+	}
+	Py_BEGIN_ALLOW_THREADS;
+	memcpy(buffer, str, len);
+	stream_encrypt(&(self->st), buffer, (int) len);
+	Py_END_ALLOW_THREADS;
+	result = PyString_FromStringAndSize((char *)buffer, len);
+	free(buffer);
+	return (result);
+}
+
+static char ALG_Decrypt__doc__[] =
+"decrypt(string): Decrypt the provided string of binary data.";
+
+static PyObject *
+ALG_Decrypt(ALGobject *self, PyObject *args)
+{
+	unsigned char *buffer, *str;
+	Py_ssize_t len;
+	PyObject *result;
+
+	if (!PyArg_Parse(args, "s#", &str, &len))
+		return NULL;
+	if (len == 0)			/* Handle empty string */
+	{
+		return PyString_FromStringAndSize(NULL, 0);
+	}
+	buffer = malloc(len);
+	if (buffer == NULL)
+	{
+		PyErr_SetString(PyExc_MemoryError, "No memory available in "
+				_MODULE_STRING " decrypt");
+		return NULL;
+	}
+	Py_BEGIN_ALLOW_THREADS;
+	memcpy(buffer, str, len);
+	stream_decrypt(&(self->st), buffer, (int) len);
+	Py_END_ALLOW_THREADS;
+	result = PyString_FromStringAndSize((char *)buffer, len);
+	free(buffer);
+	return (result);
+}
+
+/* ALGobject methods */
+
+static PyMethodDef ALGmethods[] =
+{
+	{"encrypt", (PyCFunction) ALG_Encrypt, 0, ALG_Encrypt__doc__},
+	{"decrypt", (PyCFunction) ALG_Decrypt, 0, ALG_Decrypt__doc__},
+	{NULL, NULL}			/* sentinel */
+};
+
+static PyObject *
+ALGgetattr(PyObject *self, char *name)
+{
+	if (strcmp(name, "block_size") == 0)
+	{
+		return PyInt_FromLong(BLOCK_SIZE);
+	}
+	if (strcmp(name, "key_size") == 0)
+	{
+		return PyInt_FromLong(KEY_SIZE);
+	}
+	return Py_FindMethod(ALGmethods, self, name);
+}
+
+
+/* List of functions defined in the module */
+
+static struct PyMethodDef modulemethods[] =
+{
+	{"new", (PyCFunction) ALGnew, 
+	 METH_VARARGS|METH_KEYWORDS, ALGnew__doc__},
+	{NULL, NULL}			/* sentinel */
+};
+
+static PyTypeObject ALGtype =
+{
+	PyObject_HEAD_INIT(NULL)
+	0,				/*ob_size*/
+	_MODULE_STRING,		/*tp_name*/
+	sizeof(ALGobject),	/*tp_size*/
+	0,				/*tp_itemsize*/
+	/* methods */
+	ALGdealloc,	/*tp_dealloc*/
+	0,				/*tp_print*/
+	ALGgetattr,	/*tp_getattr*/
+	0,		/*tp_setattr*/
+	0,			/*tp_compare*/
+	0,			/*tp_repr*/
+	0,				/*tp_as_number*/
+};
+
+/* Initialization function for the module */
+
+#if PYTHON_API_VERSION < 1011
+#define PyModule_AddIntConstant(m,n,v) {PyObject *o=PyInt_FromLong(v); \
+           if (o!=NULL) \
+             {PyDict_SetItemString(PyModule_GetDict(m),n,o); Py_DECREF(o);}}
+#endif
+
+void
+_MODULE_NAME (void)
+{
+	PyObject *m, *d, *x;
+
+	ALGtype.ob_type = &PyType_Type;
+	/* Create the module and add the functions */
+	m = Py_InitModule("Crypto.Cipher." _MODULE_STRING, modulemethods);
+
+	/* Add some symbolic constants to the module */
+	d = PyModule_GetDict(m);
+	x = PyString_FromString(_MODULE_STRING ".error");
+	PyDict_SetItemString(d, "error", x);
+
+	PyModule_AddIntConstant(m, "block_size", BLOCK_SIZE);
+	PyModule_AddIntConstant(m, "key_size", KEY_SIZE);
+
+	/* Check for errors */
+	if (PyErr_Occurred())
+		Py_FatalError("can't initialize module " _MODULE_STRING);
+}
+
+/* vim:set ts=8 sw=8 sts=0 noexpandtab: */