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

charm/core/crypto/cryptobase/strxor.c

@@ -0,0 +1,229 @@
+/*
+ *  strxor.c: string XOR functions
+ *
+ * Written in 2008 by Dwayne C. Litzenberger <dlitz@dlitz.net>
+ *
+ * ===================================================================
+ * 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.
+ * ===================================================================
+ */
+#include "Python.h"
+#include <stddef.h>
+#include <assert.h>
+#include <string.h>
+
+#include "pycrypto_compat.h"
+
+static const char rcsid[] = "$Id$";
+
+/*
+ * xor_strings - XOR two strings together to produce a third string
+ *
+ * dest[0..n-1] := src_a[0..n-1] ^ src_b[0..n-1]
+ *
+ */
+static void
+xor_strings(char *dest, const char *src_a, const char *src_b, size_t n)
+{
+    size_t i;
+
+    /* assert no pointer overflow */
+    assert(src_a + n > src_a);
+    assert(src_b + n > src_b);
+    assert(dest + n > dest);
+
+    for (i = 0; i < n; i++) {
+        dest[i] = src_a[i] ^ src_b[i];
+    }
+}
+
+/*
+ * xor_string_with_char - XOR a string with a char to produce another string
+ *
+ * dest[0..n-1] := src[0..n-1] ^ c
+ *
+ */
+static void
+xor_string_with_char(char *dest, const char *src, char c, size_t n)
+{
+    size_t i;
+
+    /* assert no pointer overflow */
+    assert(src + n > src);
+    assert(dest + n > dest);
+
+    for (i = 0; i < n; i++) {
+        dest[i] = src[i] ^ c;
+    }
+}
+
+/*
+ * "Import assertions"
+ *
+ * These runtime checks are performed when this module is first initialized
+ *
+ */
+
+#define IMP_ASSERT(exp) do {\
+    if (!(exp)) {\
+        PyErr_Format(PyExc_AssertionError, "%s:%d: assertion failure: '%s'", __FILE__, __LINE__, #exp);\
+        return;\
+    }\
+} while(0)
+
+static void
+runtime_test(void)
+{
+    /* size_t should be able to represent the length of any size buffer */
+    IMP_ASSERT(sizeof(size_t) == sizeof(void *));
+
+    /* we must be able to perform the assignment (Py_ssize_t) -> (size_t)
+     * as long as the value is non-negative. */
+    IMP_ASSERT(sizeof(size_t) >= sizeof(Py_ssize_t));
+
+    /* char must be one octet */
+    IMP_ASSERT(sizeof(char) == 1);
+
+    /* Perform a basic test of the xor_strings function, including a test for
+     * an off-by-one bug. */
+    {
+        char x[7] = "\x00hello";    /* NUL + "hello" + NUL */
+        char y[7] = "\xffworld";    /* 0xff + "world" + NUL */
+        char z[9] = "[ABCDEFG]";    /* "[ABCDEFG]" + NUL */
+
+        xor_strings(z+1, x, y, 7);
+        IMP_ASSERT(!memcmp(z, "[\xff\x1f\x0a\x1e\x00\x0b\x00]", 9));
+    }
+
+    /* Perform a basic test of the xor_string_with_char function, including a test for
+     * an off-by-one bug. */
+    {
+        char x[7] = "\x00hello";    /* NUL + "hello" + NUL */
+        char y = 170;               /* 0xaa */
+        char z[9] = "[ABCDEFG]";    /* "[ABCDEFG]" + NUL */
+
+        xor_string_with_char(z+1, x, y, 7);
+        IMP_ASSERT(!memcmp(z, "[\xaa\xc2\xcf\xc6\xc6\xc5\xaa]", 9));
+    }
+}
+
+/*
+ * The strxor Python function
+ */
+
+static char strxor__doc__[] =
+"strxor(a:str, b:str) -> str\n"
+"\n"
+"Return a XOR b.  Both a and b must have the same length.\n";
+
+static PyObject *
+strxor_function(PyObject *self, PyObject *args)
+{
+    PyObject *a, *b, *retval;
+    Py_ssize_t len_a, len_b;
+
+    if (!PyArg_ParseTuple(args, "SS", &a, &b))
+        return NULL;
+
+    len_a = PyString_GET_SIZE(a);
+    len_b = PyString_GET_SIZE(b);
+
+    assert(len_a >= 0);
+    assert(len_b >= 0);
+
+    if (len_a != len_b) {
+        PyErr_SetString(PyExc_ValueError, "length of both strings must be equal");
+        return NULL;
+    }
+
+    /* Create return string */
+    retval = PyString_FromStringAndSize(NULL, len_a);
+    if (!retval) {
+        return NULL;
+    }
+
+    /* retval := a ^ b */
+    xor_strings(PyString_AS_STRING(retval), PyString_AS_STRING(a), PyString_AS_STRING(b), len_a);
+
+    return retval;
+}
+
+/*
+ * The strxor_c Python function
+ */
+
+static char strxor_c__doc__[] =
+"strxor_c(s:str, c:int) -> str\n"
+"\n"
+"Return s XOR chr(c).  c must be in range(256).\n";
+
+static PyObject *
+strxor_c_function(PyObject *self, PyObject *args)
+{
+    PyObject *s, *retval;
+    int c;
+    Py_ssize_t length;
+
+    if (!PyArg_ParseTuple(args, "Si", &s, &c))
+        return NULL;
+
+    if ((c < 0) || (c > 255)) {
+        PyErr_SetString(PyExc_ValueError, "c must be in range(256)");
+        return NULL;
+    }
+
+    length = PyString_GET_SIZE(s);
+    assert(length >= 0);
+
+    /* Create return string */
+    retval = PyString_FromStringAndSize(NULL, length);
+    if (!retval) {
+        return NULL;
+    }
+
+    /* retval := a ^ chr(c)*length */
+    xor_string_with_char(PyString_AS_STRING(retval), PyString_AS_STRING(s), (char) c, length);
+
+    return retval;
+}
+
+/*
+ * Module-level method table and module initialization function
+ */
+
+static PyMethodDef strxor_methods[] = {
+    {"strxor", strxor_function, METH_VARARGS, strxor__doc__},
+    {"strxor_c", strxor_c_function, METH_VARARGS, strxor_c__doc__},
+
+    {NULL, NULL, 0, NULL}   /* end-of-list sentinel value */
+};
+
+PyMODINIT_FUNC
+initstrxor(void)
+{
+    PyObject *m;
+
+    /* Initialize the module */
+    m = Py_InitModule("strxor", strxor_methods);
+    if (m == NULL)
+        return;
+
+    /* Perform runtime tests */
+    runtime_test();
+}
+
+/* vim:set ts=4 sw=4 sts=4 expandtab: */

charm/core/engine/__init__.py

@@ -0,0 +1,5 @@
+
+#from protocol import *
+#from util import *
+
+

charm/core/engine/protocol.py

@@ -0,0 +1,293 @@
+# TODO: provide a transition checker that prevents a feedback loop, inconsistent state.
+# in user db that way user can eliminate store step on the receive side.
+
+from charm.core.engine.util import *
+from charm.toolbox.enum import Enum
+from math import log, ceil
+
+debug = False
+# standardize responses between client and server
+# code = Enum('Success', 'Fail', 'Repeat', 'StartSubprotocol', 'EndSubprotocol')
+class Protocol:
+    def __init__(self, error_states, max_size=2048): # any init information?
+        global error
+        self.p_ID = 0
+        self.p_ctr = 0
+        error = error_states
+        # dictionary of party types (each type gets an identifier)
+        self.partyTypes = {}
+        self.party = {}
+        self._serialize = False
+        self.db = {} # initialize the database
+        self.max_size = max_size
+        self.prefix_size = ceil(log(max_size, 256))
+        
+    def setup(self, *args):
+        # handles the hookup between parties involved
+        Error = True
+        for arg in args:
+            if isinstance(arg, dict):
+               print("Setup of: ", arg['name'])
+               if not self.addInstance(arg): Error = False
+            else:
+               print(type(arg))
+        return Error
+
+    def addInstance(self, obj):
+        p_ctr = self.p_ctr
+        for i in self.partyTypes.keys():
+            if i == obj['type']: # we find the party type
+               self.party[p_ctr] = {}
+               self.party[p_ctr]['name'], self.party[p_ctr]['socket'] = obj['name'], obj['socket']
+               self.party[p_ctr]['type'], self.party[p_ctr]['states'] = obj['type'], self.partyTypes[i]['states']
+               self.party[p_ctr]['init'] = self.partyTypes[i]['init']
+               self.p_ctr += 1
+               print("Adding party instance w/ id: ", p_ctr)
+               return True
+        return None
+
+    def addPartyType(self, type, state_map, trans_map, init_state=False):
+        ExistingTypeFound = False
+        # see if type already exists. break and return if so
+        for i in self.partyTypes.keys():
+            if self.partyTypes[i]['type'] == type:
+                ExistingTypeFound = True
+                break
+        # means we are adding a new type    
+        if not ExistingTypeFound:
+           p_ID = self.p_ID
+           party = {'type':type, 'id':p_ID }
+           if(isinstance(state_map, dict)):
+              party['states'] = state_map # function pointers for state functions...
+           if(isinstance(trans_map, dict)):
+              party['transitions'] = trans_map          
+           party['init'] = init_state  # which state initializes the protocol
+           self.partyTypes[type] = party  # makes sure
+           self.p_ID += 1
+           return True
+        return False
+#    
+#    def addValidTransitions(self, trans_map):
+#        if isinstance(trans_map, dict):    
+#            self.trans_map = trans_map
+   
+    def listStates(self, partyID):
+        # check if a member parameter is defined
+        if partyID < self.p_ctr:
+            return self.party[partyID]['states']
+        return None
+    
+    def listParties(self):
+        return list(self.party.keys())
+
+    def listParyTypes(self):
+        return list(self.partyTypes.keys())
+
+    def getInitState(self, _type):
+        for i in self.listParties():
+            if self.party[i]['type'] == _type: 
+                self._socket = self.party[i]['socket'] 
+                if self.party[i]['init']:
+                    # set current trans starting point
+                    self.cur_state = 1
+                    return (True, self.listStates(i)[1])
+                else:
+                    self.cur_state = 2
+                    return (False, self.listStates(i)[2])
+        print("Returning junk!")
+        return (False, None)
+    
+    def setState(self, state_num):
+        # find the corresponding call back based on current party id
+        self.nextCall = None        
+        if state_num == None: return None   
+        nextPossibleState = self._cur_trans.get(self.cur_state)
+        if type(nextPossibleState) == list and not state_num in nextPossibleState:
+           print("Invalid State Transition! Error!")
+           print("\tCurrent state: ", self.cur_state)
+           print("\tNext state: ", state_num)
+           print("Allowed states: ", nextPossibleState)        
+        elif type(nextPossibleState) != list and nextPossibleState != state_num: 
+           print("Invalid State Transition! Error!")
+           print("\tCurrent state: ", self.cur_state)
+           print("\tNext state not allowed: ", state_num)
+           # do not make the transition
+           return None
+            
+        for i in self.listParties():
+            states = self.listStates(i)
+            if states.get(state_num) != None: 
+               self.nextCall = states.get(state_num)
+               # preparing for state transition here.
+               self.cur_state = state_num
+               break
+        return None
+    
+    def send_msg(self, object):
+        # use socket to send message (check if serializaton is required)
+        if self._socket != None:
+            if self._serialize:
+                result = self._user_serialize(object)
+            else:
+                result = self.serialize(object)
+                #print("DEBUG: send_msg : result =>", result)
+            if len(result) > self.max_size:
+                print("Message too long! max_size="+str(self.max_size))
+                return None
+            result = len(result).to_bytes(length=self.prefix_size, byteorder='big') + result
+            self._socket.send(result)
+        return None
+
+    # receives exactly n bytes
+    def recv_all(self, n):
+        recvd = 0
+        res = b''
+        while recvd < n:
+            res = res + self._socket.recv(n-recvd)
+            recvd = len(res)
+        return res
+
+    def recv_msg(self):
+        # read the socket and return the received message (check if deserialization)
+        # is necessary
+        if self._socket != None:
+            # block until data is available or remote host closes connection
+            msglen = int.from_bytes(self.recv_all(self.prefix_size), byteorder='big')
+            result = self.recv_all(msglen)
+
+            if result == '': return None
+            else: 
+                if self._serialize:
+                    return self._user_deserialize(result)
+                else: # default serialize call
+                    return self.deserialize(result)
+        return None
+    
+#    # serialize an object
+#    def serialize(self, object):
+#        if type(object) == str:
+#            return bytes(object, 'utf8')
+#        return object
+#    
+#    def deserialize(self, object):
+#        if type(object) == bytes:
+#            return object.decode('utf8')
+#        return object
+    def setSubclassVars(self, group, state=None):
+        if hasattr(group, 'serialize') and hasattr(group, 'deserialize'):
+            self.group = group
+        if state != None:
+            if type(state) == dict:
+                self.db = state
+        
+    def get(self, keys, _type=tuple):
+        if not type(keys) == list: return
+        if _type == tuple:
+            ret = []
+        else: ret = {}
+        # get the data 
+        for i in keys:
+            if _type == tuple:
+                ret.append(self.db[i])
+            else: # dict
+                ret[ i ] = self.db[i]            
+        # return data
+        if _type == tuple:                
+            return tuple(ret)
+        return ret
+    
+    def store(self, *args):
+        for i in args:
+            if isinstance(i, tuple):
+                self.db[ i[0] ] = i[1]
+        return None
+    
+    def serialize(self, object):
+#        print("input object... => ", object)
+        if type(object) == dict:
+            bytes_object = serializeDict(object, self.group)
+            return pickleObject(bytes_object)
+        elif type(object) == str:
+            return pickleObject(object)
+        else:
+#            print("serialize: just =>", object)
+            return object
+    
+    def deserialize(self, bytes_object):
+#        print("deserialize input =>", bytes_object)
+        if type(bytes_object) == bytes:
+            object = unpickleObject(bytes_object)
+            if isinstance(object, dict):
+                return deserializeDict(object, self.group)            
+                
+            return object
+    # OPTIONAL
+    # derived class must call this function in order to 
+    def setSerializers(self, serial, deserial):
+        self._serialize = True
+        self._user_serialize = serial
+        self._user_deserialize = deserial
+        return None
+        
+    # records the final state of a protocol execution
+    def setErrorCode(self, value):
+        self.result = value
+        
+    # executes state machine from the 'party_type' perspective 
+    def execute(self, party_type, close_sock=True):
+        print("Party Descriptions:")
+        print(self.listParyTypes(), "\n")
+#        print("Executing protocol engine...")
+        # assume there are two parties: support more in the future.
+#        if len(self.listParties()) == 2:
+#            p1, p2 = self.listParties()
+#        print(self.listParties())
+            
+        # main loop
+#        Timeout = False
+        (start, func) = self.getInitState(party_type)
+        self._cur_trans = self.partyTypes[party_type]['transitions'] 
+        #print("Possible transitions: ", self._cur_trans)
+        print("Starting Point => ", func.__name__)
+        if start == True:
+            # call the first state for party1, then send msg
+            output = func.__call__()
+            if type(output) == dict: self.db.update(output)
+            self.send_msg(output)
+        else:
+            # first receive message, call state function
+            # then send call response
+            input = self.recv_msg()
+            if type(input) == dict:
+#                print("input db :=>", input)
+                self.db.update(input)
+            output = func.__call__(input)
+            if isinstance(output, dict):
+#                print("output db :=>", output)
+                self.db.update(output)
+            self.send_msg(output)
+        # take output and send back to other party via socket
+
+        while self.nextCall != None: 
+             input = self.recv_msg()
+             if isinstance(input, dict): self.db.update(input)
+             output = self.nextCall.__call__(input)
+             if output != None: 
+                 if isinstance(output, dict): self.db.update(output)
+                 self.send_msg(output)
+        if close_sock:
+           self.clean()
+        return output
+    
+    def check(self):
+        # cycle through parties, make sure they are differntly typed?
+        # p_ID must be at least 2
+        # ...
+        pass
+    
+    def clean(self):
+        if debug: print("Cleaning database...")
+        self._socket.close()
+        self.db.clear()
+        print("PROTOCOL COMPLETE!")
+        return None

charm/core/engine/util.py

@@ -0,0 +1,174 @@
+"""
+The serialization API supports the following datatypes: dict, list, str, bytes, int, float, and whatever is supported by group.serialize and group.deserialize
+
+"""
+
+from __future__ import print_function
+import io, pickle
+import json, zlib
+from base64 import *
+from charm.toolbox.bitstring import *
+
+def serializeDict(Object, group):
+    return {
+        k: serializeObject(o, group)
+        for k, o in Object.items()
+    }
+
+def serializeList(Object, group):
+    return [
+        serializeObject(o, group)
+        for o in Object
+    ]
+
+serializers = {
+    dict: serializeDict,
+    list: serializeList,
+    tuple: serializeList,
+    str: lambda obj, g: 'str:' + obj,
+    bytes: lambda obj, g: 'bytes:' + obj.decode('UTF-8'),
+    int: lambda obj, g: obj,
+    float: lambda obj, g: obj,
+}
+
+def serializeObject(Objects, group):
+    assert hasattr(group, 'serialize'), "group does not have serialize method"
+
+    try:
+        serializer = serializers[type(Objects)]
+    except KeyError:
+        return group.serialize(Objects)
+
+    return serializer(Objects, group)
+
+
+def deserializeDict(Object, group):
+    return {
+        k: deserializeObject(o, group)
+        for k, o in Object.items()
+    }
+
+
+def deserializeList(Object, group):
+    return [
+        deserializeObject(o, group)
+        for o in Object
+    ]
+
+
+def deserializeTuple(Object, group):
+    return tuple(deserializeList(Object, group))
+
+
+def deserializeStr(object, group):
+    typ, obj = object.split(':', 1)
+
+    if typ == 'str':
+        return str(obj)
+    elif typ == 'bytes':
+        return getBytes(obj)
+
+deserializers = {
+    dict: deserializeDict,
+    list: deserializeList,
+    tuple: deserializeTuple,
+    str: deserializeStr,
+    bytes: lambda obj, group: group.deserialize(obj)
+}
+
+def deserializeObject(Objects, group):
+    assert hasattr(group, 'deserialize'), "group does not have deserialize method"
+
+    try:
+        deserializer = deserializers[type(Objects)]
+    except KeyError:
+        return Objects
+
+    return deserializer(Objects, group)
+    
+def pickleObject(Object):
+    valid_types = [bytes, dict, list, str, int]    
+    file = io.BytesIO()
+    # check that dictionary is all bytes (if not, return None)
+    if isinstance(Object, dict):
+        for k in Object.keys():
+            _type = type(Object[k])
+            if not _type in valid_types:
+               print("DEBUG: pickleObject Error!!! only bytes or dictionaries of bytes accepted."); print("invalid type =>", type(Object[k]))
+               return None
+    pickle.dump(Object, file, pickle.HIGHEST_PROTOCOL)
+    result = file.getvalue()
+    encoded = b64encode(result)
+    file.close()
+    return encoded
+
+def unpickleObject(Object):
+    """Unpickle a base64-encoded object.
+
+    WARNING: This function uses pickle.loads() which can execute arbitrary code
+    when deserializing untrusted data. Only use this with trusted input.
+    This is kept for backward compatibility with existing serialized data.
+    """
+    if type(Object) == str or type(Object) == bytes:
+       byte_object = Object
+    else:
+       return None
+    decoded = b64decode(byte_object)
+    if type(decoded) == bytes and len(decoded) > 0:
+        return pickle.loads(decoded)  # nosec B301 - intentional use for trusted data
+    return None
+
+# JSON does not support 'bytes' objects, so these from/to_json 
+# functions handle protecting the 
+def to_json(object):
+    if isinstance(object, bytes):
+        return {'__class__': 'bytes', '__value__': list(object) }
+    elif isinstance(object, tuple):
+        return {'__class__': 'tuple', '__value__': list(object) }
+    return TypeError(repr(object) + " is not JSON serializable")
+
+def from_json(json_object):
+    if '__class__' in json_object:
+        if json_object['__class__'] == 'bytes':
+            return bytes(json_object['__value__'])
+        elif json_object['__class__'] == 'tuple':
+            return tuple(json_object['__value__'])
+    return json_object
+
+# Two new API calls to simplify serializing to a blob of bytes
+# objectToBytes() and bytesToObject()
+def objectToBytes(object, group):
+    object_ser = serializeObject(object, group)
+    #result = pickleObject(object_ser)
+    result = getBytes(json.dumps(object_ser, default=to_json))
+    return b64encode(zlib.compress(result))
+    
+def bytesToObject(byteobject, group):
+    #unwrap_object = unpickleObject(byteobject)
+    decoded = bytes.decode(zlib.decompress(b64decode(byteobject)))
+    unwrap_object = json.loads(decoded, object_hook=from_json)
+    return deserializeObject(unwrap_object, group)
+
+# Note: included for backwards compatibility with older versions. 
+# Will be removed completely in future versions.
+def objectToBytesWithPickle(Object, group):
+    object_ser = serializeObject(Object, group)
+    return pickleObject(object_ser)
+    
+def bytesToObjectWithPickle(byteobject, group):
+    print("SecurityWarning: do not unpickle data received from an untrusted source. Bad things WILL happen!")
+    unwrap_object = unpickleObject(byteobject)
+    return deserializeObject(unwrap_object, group)
+    
+"""
+    Using serialization tools with our cryptographic schemes 
+    requires that the group object is initialized 
+    
+    data = { 'test1':b"hello", 'test2':b"world", }
+    
+    dataBytes = objectToBytes(data, group)
+    
+    dataRec   = bytesToObject(dataBytes, group)
+
+    assert data == dataRec, 'Error during deserialization.'
+"""