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

charm/toolbox/reCompiler.py

@@ -0,0 +1,346 @@
+r""" Module re_compile -- compile a regular expression into an FSA
+
+To Do
+-----
+New features:
+    - add \-, \~
+    - add remaining metachars
+    - char set with ^ as first char will print wrong
+    - figure out when to print spaces between operators
+"""
+
+__author__  = "Oliver Steele <steele@osteele.com>"
+
+from functools import reduce
+import charm.toolbox.FSA as FSA
+
+def compileSymbolRE(str):
+    return SymbolRECompiler(str).toFSA()
+
+def dummy_func(a, b):
+    return a, b 
+    
+class SymbolRECompiler:
+    EOF = -1
+    
+    def __init__(self, str, recordSourcePositions=0):
+        self.str = str
+        self.recordSourcePositions = recordSourcePositions
+    
+    def toFSA(self, minimize=1):
+        self.index = 0
+        self.nextToken = None
+        fsa = self.compileExpr()
+        if self.index < len(self.str):
+            raise ValueError('extra ' + str(')'))
+        del self.index
+        fsa.label = self.str
+        if minimize:
+            fsa = fsa.minimized()
+        return fsa
+    
+    def readChar(self):
+        if self.index < len(self.str):
+            c, self.index = self.str[self.index], self.index + 1
+            return c
+    
+    def peekChar(self):
+        if self.index < len(self.str):
+            return self.str[self.index]
+    
+    def readToken(self):
+        token = self.nextToken or self._readNextToken()
+        self.nextToken = None
+        return token != self.EOF and token
+    
+    def peekToken(self):
+        token = self.nextToken = self.nextToken or self._readNextToken()
+        #print 'peekToken', token
+        return token != self.EOF and token
+    
+    def _readNextToken(self):
+        c = self.readChar()
+        if not c:
+            return self.EOF
+        elif c in '()|&':
+            return c
+        elif c == '.':
+            return ANY
+        return c
+    
+    def skipTokens(self, bag):
+        while self.peekToken() and self.peekToken() in bag:
+            self.readToken()
+    
+    def compileExpr(self):
+        fsa = FSA.NULL_FSA
+        while self.peekToken() and self.peekToken() != ')':
+            fsa = FSA.union(fsa, self.compileConjunction())
+            self.skipTokens(['|'])
+        return fsa
+    
+    def compileConjunction(self):
+        fsa = None
+        while self.peekToken() and self.peekToken() not in (')', '|'):
+            sequence = self.compileSequence()
+            fsa = fsa and FSA.intersection(fsa, sequence) or sequence
+            self.skipTokens(['&'])
+        return fsa
+    
+    def compileSequence(self):
+        fsa = FSA.EMPTY_STRING_FSA
+        while self.peekToken() and self.peekToken() not in (')', '|', '&'):
+            fsa = FSA.concatenation(fsa, self.compileItem())
+        return fsa
+    
+    def compileItem(self):
+        startPosition = self.index
+        c = self.readToken()
+        if c == '(':
+            fsa = self.compileExpr()
+            if self.readToken() != ')':
+                raise ValueError("missing ')'")
+        elif c == '~':
+            fsa = FSA.complement(self.compileItem())
+        else:
+            fsa = FSA.singleton(c, arcMetadata=self.recordSourcePositions and [startPosition])
+        while self.peekChar() and self.peekChar() in '?*+':
+            c = self.readChar()
+            if c == '*':
+                fsa = FSA.closure(fsa)
+            elif c == '?':
+                fsa = FSA.union(fsa, FSA.EMPTY_STRING_FSA)
+            elif c == '+':
+                fsa = FSA.iteration(fsa)
+            else:
+                raise ValueError('program error')
+        return fsa
+
+
+#
+# Character REs
+#
+
+class CharacterSet:
+    def __init__(self, ranges):
+        if type(ranges) == str:
+            ranges = self.convertString(ranges)
+        accum = []
+        # copy, so sort doesn't destroy the arg
+        for item in ranges:
+            if type(item) == tuple:
+                if len(item) == 1:
+                    accum.append((item, item))
+                elif len(item) == 2:
+                    accum.append(item)
+                else:
+                    raise ValueError("invalid argument to CharacterSet")
+            elif type(item) == str:
+                for c in item:
+                    accum.append((c, c))
+            else:
+                raise ValueError("invalid argument to CharacterSet")
+        ranges = accum
+        ranges.sort()
+        index = 0
+        while index < len(ranges) - 1:
+            [(c0, c1), (c2, c3)] = ranges[index:index + 2]
+            if c1 >= c2:
+                ranges[index:index + 2] = [(c0, max(c1, c3))]
+            else:
+                index = index + 1
+        self.ranges = ranges
+    
+    def __cmp__(self, other):
+        return cmp(type(self), type(other)) or cmp(self.__class__, other.__class__) or cmp(self.ranges, other.ranges)
+
+    def __hash__(self):
+        return reduce(lambda a, b:a ^ b, map(hash, self.ranges))
+    
+    def convertString(self, _str):
+        ranges = []
+        index = 0
+        while index < len(_str):
+            c0 = c1 = _str[index]
+            index = index + 1
+            if index + 1 < len(_str) and _str[index ] == '-':
+                c1 = _str[index + 1]
+                index = index + 2
+            ranges.append((c0, c1))
+        return ranges
+    
+    def matches(self, c):
+        for c0, c1 in self.ranges:
+            if c0 <= c and c <= c1:
+                return 1
+        return 0
+    
+    def complement(self):
+        results = []
+        for (_, c0), (c1, _) in map(dummy_func, [(None, None)] + self.ranges, self.ranges + [(None, None)]):
+            i0 = c0 and ord(c0) + 1 or 0
+            i1 = c1 and ord(c1) - 1 or 255
+            if i0 <= i1:
+                results.append((chr(i0), chr(i1)))
+        if results:
+            return CharacterSet(results)
+    
+    def union(self, other):
+        a = self.complement()
+        b = other.complement()
+        if a and b:
+            c = a.intersection(b)
+            if c:
+                return c.complement()
+            else:
+                return self.ANY
+        else:
+            return a or b
+
+    def __add__(self, other):
+        return self.union(other)
+    
+    def intersection(self, other):
+        if self.ranges == other.ranges:
+            return self
+        results = []
+        for (a0, a1) in self.ranges:
+            for (b0, b1) in other.ranges:
+                c0 = max(a0, b0)
+                c1 = min(a1, b1)
+                if c0 <= c1:
+                    results.append((c0, c1))
+        results.sort()
+        if results:
+            return CharacterSet(results)
+    
+    def __str__(self):
+        """
+        ### print(CharacterSet([('a', 'a')]))
+        a
+        ### print(CharacterSet([('a', 'b')]))
+        [ab]
+        """
+        if self == self.ANY:
+            return '.'
+        elif not self.ranges:
+            return '[^.]'
+        for key, value in METACHARS.items():
+            if self == value:
+                return '\\' + key
+        ranges = self.ranges
+        if len(ranges) == 1 and ranges[0][0] == ranges[0][1]:
+            return ranges[0][0]
+        if ranges[0][0] == chr(0) and ranges[-1][1] == chr(255):
+            s = str(self.complement())
+            if s[0] == '[' and s[-1] == ']':
+                s = s[1:-1]
+            return '[^' + s + ']'
+        s = ''
+        for c0, c1 in ranges:
+            if c0 == c1 and c0 != '-':
+                s = s + self.crep(c0)
+            elif ord(c0) + 1 == ord(c1) and c0 != '-' and c1 != '-':
+                s = s + "%s%s" % (self.crep(c0), self.crep(c1))
+            else:
+                s = s + "%s-%s" % (self.crep(c0), self.crep(c1))
+        return '[' + s + ']'
+    
+    def crep(self, c):
+        return {'\t': '\\t', '\n': '\\n', '\r': '\\r', '\f': '\\f', '\v': '\\v'}.get(c, c)
+    
+    def __repr__(self):
+        return '<' + self.__class__.__name__ + ' ' + str(self) + '>'
+
+METACHARS = {
+        'd': CharacterSet('0-9'),
+        's': CharacterSet(' \t\n\r\f\v'),
+        'w': CharacterSet('a-zA-Z0-9')}
+METACHARS['D'] = METACHARS['d'].complement()
+METACHARS['S'] = METACHARS['s'].complement()
+METACHARS['W'] = METACHARS['w'].complement()
+
+CharacterSet.ANY = CharacterSet([(chr(0), chr(255))])
+
+
+class RECompiler(SymbolRECompiler):
+    def _readNextToken(self):
+        c = self.readChar()
+        if not c:
+            return self.EOF
+        elif c in '()|':
+            return c
+        elif c == '.':
+            return CharacterSet.ANY
+        elif c == '[':
+            if self.peekChar() == '~':
+                self.readChar()
+                return self.readCSetInnards().complement()
+            else:
+                return self.readCSetInnards()
+        elif c == '\\':
+            c = self.readChar()
+            if METACHARS.get(c):
+                return METACHARS.get(c)
+            elif c == '&':
+                return c
+            else:
+                return CharacterSet([(c,c)])
+        else:
+            return CharacterSet([(c,c)])
+    
+    def readCSetInnards(self):
+        cset = CharacterSet([])
+        while 1:
+            c = self.readChar()
+            if c == ']':
+                return cset
+            if self.peekChar() == '-':
+                self.readChar()
+                cset = cset.union(CharacterSet([(c, self.readChar())]))
+            else:
+                cset = cset.union(CharacterSet([(c, c)]))
+
+def compileRE(_str, minimize=1, recordSourcePositions=0):
+    return RECompiler(_str, recordSourcePositions=recordSourcePositions).toFSA(minimize=minimize)
+
+#
+# testing
+#
+def _printCompiledREs():
+    print (compileRE('a'))
+    print (compileRE('ab'))
+    print (compileRE('a|b'))
+    print (compileRE('abc'))
+    print (compileRE('ab*c'))
+    print (compileRE('ab?c'))
+    print (compileRE('ab+c'))
+    print (compileRE('ab|c'))
+    print (compileRE('a(b|c)'))
+    #print compileRE('a\&a')
+    #print compileRE('ab+\&a+b')
+    #print compileRE('ab*\&a*b')
+    print (compileRE('ab|c?'))
+    print (compileRE('ab|bc?'))
+    print (compileRE('a?'))
+    print (compileRE('abc|acb|bac|bca|cab|cba'))
+    print (compileRE('abc|acb|bac|bca|cab|cba', 0).determinized())
+    print (compileRE('abc|acb|bac|bca|cab|cba', 0).determinized())
+    print (compileRE('abc|acb|bac|bca|cab|cba', 0).minimized())
+    print (compileRE('abc|acb|bac|bca|cab', 0).determinized())
+
+    print (compileRE('a', 0))
+    print (compileRE('a', 0).determinized())
+    print (compileRE('ab', 0).determinized())
+    print (compileRE('a', 0).minimized())
+    print (compileRE('ab', 0).minimized())
+    print (compileRE('a'))
+    print (compileRE('a|b', 0).determinized())
+    print (compileRE('a|b', 0).minimized().getArcMetadata())
+    print (compileRE('a|b', 0).minimized())
+
+def _test(reset=0):
+    import doctest, compileRE
+    if reset:
+        doctest.master = None # This keeps doctest from complaining after a reload.
+    return doctest.testmod(compileRE)

charm/toolbox/redundancyschemes.py

@@ -0,0 +1,65 @@
+'''A collection of redundancy schemes'''
+from charm.toolbox.bitstring import Bytes,py3
+from charm.toolbox.securerandom import SecureRandomFactory
+import charm.core.crypto.cryptobase
+import hashlib
+import math
+import struct
+import sys
+
+debug = False
+
+
+class InMessageRedundancy:
+    '''
+    :Authors: Christina Garman
+    '''
+    def __init__(self):
+        pass        
+
+    def encode(self, message):
+        str_message = message.decode("utf-8")
+        str_message += str_message[-8:]
+
+        return str_message.encode("utf-8")
+    
+    def decode(self, encMessage):
+        byte_message = bytearray(encMessage)
+
+        if(byte_message[-8:] ==  byte_message[-16:-8]):
+            return (True,bytes(byte_message[:-8]))
+        else:
+            return (False,bytes(byte_message[:-8]))
+
+class ExtraBitsRedundancy:
+    '''
+    :Authors: Christina Garman
+    
+    TODO    
+    '''
+    def __init__(self):
+        pass        
+
+    def encode(self, message):
+             
+        return Bytes(b'\x00') + maskedSeed + maskedDB
+    
+    def decode(self, encMessage, label=""):
+
+        return M
+class WilliamsRedundancy:
+    '''
+    :Authors: Christina Garman
+
+    TODO    
+    '''
+    def __init__(self):
+        pass        
+
+    def encode(self, message):
+             
+        return Bytes(b'\x00') + maskedSeed + maskedDB
+    
+    def decode(self, encMessage, label=""):
+
+        return M

charm/toolbox/schemebase.py

@@ -0,0 +1,188 @@
+from charm.toolbox.enum import *
+
+# user-map
+EU_CMA,SU_CMA="EU_CMA","SU_CMA"
+SM,ROM,CRS = "SM","ROM","CRS"
+OW,RSA,StrongRSA,DL,DH,CDH,DDH,DBDH,q_SDH,LRSW = "OW","RSA","StrongRSA","DL","DH","CDH","DDH","DBDH","q_SDH","LRSW"
+
+# security models: standard, random oracle and common reference string
+baseSecModels = Enum('SM', 'ROM', 'CRS')
+# scheme types
+SchemeType = Enum('PKEnc', 'PKSig', 'IBEnc', 'IBSig', 'RingSig', 'GroupSig', 'ABEnc', 'DABEnc','Commitment', 'Hash', 'ChamHash', 'Protocol', 'PREnc')
+# security hardness assumptions
+secAssump = Enum('OW','RSA','StrongRSA','DL','DH','CDH','DDH','DBDH','q_SDH','LRSW') # need to expand this since it captures implications
+
+schemeType = "scheme"
+assumptionType = "assumption"
+messageSpaceType = "messageSpace"
+secModelType = "secModel"
+secDefType   = "secDef"
+
+class SchemeBase:
+    '''Base class for all crypto, which defines security properties of cryptosystem'''
+    def __init__(self):
+        self.properties = {}
+        
+    def _setProperty(self, scheme=None, secDef=None, assumption=None, messageSpace=None, secModel=None, **kwargs):
+        if scheme is not None and scheme in SchemeType.getList(): self.properties[ schemeType ] = SchemeType[scheme]
+        if assumption is not None and assumption in secAssump.getList(): self.properties[ assumptionType ] = secAssump[assumption]
+        if messageSpace is not None and type(messageSpace) == list:
+            self.properties[ messageSpaceType ] = list(messageSpace)
+        elif messageSpace is not None:
+            self.properties[ messageSpaceType ] = messageSpace # TODO: better error handling here
+
+        if secModel is not None and secModel in baseSecModels.getList(): self.properties[ secModelType ] = baseSecModels[secModel]
+        if secDef is not None: self.properties[ secDefType ] = secDef # defined by subclass
+        for key in kwargs.keys():
+            self.properties[ key ] = kwargs[key]
+        return True
+
+    def _getProperty(self):
+        return dict(self.properties)
+
+    def _checkProperty(self, scheme, prop):
+        # verify scheme is a subclass of SchemeBase
+        if not hasattr(scheme, 'getProperty'): 
+            assert False, "ERROR: Scheme class not derived from any of the Charm scheme types."
+
+        if type(prop) == list:
+           criteria = list(prop)
+           #print("criteria: ", criteria)
+           targetProps = scheme.getProperty()
+           #print("check list =>", targetProps)
+           for k,v in criteria:
+               #print(k, ":", v)
+               if k in targetProps.keys():
+                   # found a match
+                   if (v == str(targetProps[k])):
+                       continue
+                   # criteria value is less than target value
+                   elif v in baseSecModels.getList() and baseSecModels[v] < targetProps[k]:
+                       continue
+               else:
+                   assert False, "ERROR: required property not in scheme dictionary or not satisfied: %s" % k
+        return True
+    
+    @classmethod
+    def verifyTypeStruct(self, source, target, _types=dict):
+        # make sure src and targ the same type otherwise raise error
+        if type(source) != type(target): 
+           assert False, "type mismatch between src='%s' and targ='%s'" % (type(source), type(target)) 
+        if _types == dict: _iter = target.keys()
+        elif _types in [list, tuple]: 
+           _iter = range(len(source))
+           target = [target[0] for i in _iter] 
+           #print("target =>", target)
+        #if struct unknown, then we shouldn't be calling this method
+        else:
+           assert False, "invalid structure type. wrong method"
+
+        for i in _iter:            
+            if hasattr(source[i], 'type'): # check for charm elements
+                assert source[i].type == target[i], "invalid type: '%s' should be '%s' not '%s'" % (i, target[i], source[i].type)
+            elif type(source[i]) in [dict, tuple, list]: # all dict elements (charm or python) must match target type
+                keys = source[i].keys() if type(source[i]) == dict else range(len(source[i]))
+                for j in keys:
+                    if hasattr(source[i][j ], 'type'):
+                        assert source[i][j].type == target[i], "invalid type: '%s' should be '%s' not '%s'" % (j, target[i], source[i][j].type)
+                    else:
+                        assert type(source[i][j]) == target[i], "invalid type: %s" % (target[i], type(source[i][j]))
+            else: # normal python type
+                assert type(source[i]) == target[i], "invalid type: %s not %s" % (target[i], type(source[i]))
+        return True
+    
+    @classmethod
+    def verifyType(self, source, target):
+        if hasattr(source, 'type'):
+            # source must be one of our base module types
+            if source.type == target: 
+               return True
+            else: return False
+        elif type(source) == target:
+            return True
+    
+    @classmethod
+    def getTypes(self, object, keys, _type=tuple):
+        if _type == tuple:
+            ret = []
+        else: ret = {}
+        # get the data 
+        for i in keys:
+            if _type == tuple:
+                ret.append(object.__annotations__[i])
+            else: # dict
+                ret[ i ] = object.__annotations__[i]            
+        # return data
+        if _type == tuple:                
+            return tuple(ret)
+        return ret
+
+"""
+Decorator to handle checking an algorithms inputs and validating that types
+match. The only requirement other than structure def matching is that the type
+associated with the elements match target type (both python and charm types).
+"""
+class Input:
+    def __init__(self, *_types):
+        self._types = _types
+        #print("INPUT TYPE: Defined types: ", self._types)
+    
+    def __call__(self, func, *args):
+        def check_input(*args):
+            result = None
+            try:
+                # check inputs
+                inputs = args[1:]
+                for i in range(0, len(self._types)):
+                   _res_type = type(self._types[i])
+                   if _res_type in [list, dict]: # make sure it's either a dict, list or tuple
+                     assert SchemeBase.verifyTypeStruct(inputs[i], self._types[i], _res_type), "invalid '%s' type for '%s'" % (self._types[i], i)
+                   else:
+                     assert SchemeBase.verifyType(inputs[i], self._types[i]), "invalid '%s' type for '%s'" % (self._types[i], i)
+                result = func(*args)
+            except Exception as e:
+                print(e)
+            return result
+        
+        return check_input
+
+"""
+Decorator to handle checking an algorithms outputs and validating that types
+match. Similar to input, the only requirement other than structure def matching is that the type
+associated with the elements match target type (both python and charm types).
+"""
+class Output:
+    def __init__(self, *_types):
+        self._types = _types
+        self._type_len = len(_types)
+        self.check_first = True
+        if self._type_len > 1: self.check_first = False
+        #print("OUTPUT TYPE: ", self._types)
+
+    def __call__(self, func, *args):
+        def check_output(*args):
+            # we do not mask error raised by the function not related to types
+            output = func(*args)
+            try:
+                # check the output        
+                if self.check_first:
+                    # situation where only one type is defined and it could be a single dict or list of many types, 
+                    # or a single object with one type  
+                    _res_type = type(self._types[0])
+                    if _res_type in [list, dict]:
+                        assert SchemeBase.verifyTypeStruct(output, self._types[0], _res_type), "invalid return type"
+                    else:
+                        assert SchemeBase.verifyType(output, self._types[0]), "invalid return output for '%s'" % func.__name__
+                else:        
+                    # situation where a list of types is defined and mirrors how we look at inputs
+                    for i in range(0, self._type_len):              
+                        if type(self._types[i]) == dict:
+                            assert SchemeBase.verifyTypeStruct(output[i], self._types[i]), "invalid return type"
+                        elif type(self._types[i]) == tuple:
+                            assert SchemeBase.verifyTypeStruct(output[i], self._types[i], list)
+                        else:
+                            assert SchemeBase.verifyType(output[i], self._types[i]), "invalid return type"
+            except Exception as e:
+                print(e)
+            return output
+        return check_output

charm/toolbox/secretshare.py

@@ -0,0 +1,104 @@
+# Implementing the proof of concept secret sharing 
+from charm.toolbox.pairinggroup import PairingGroup,ZR,order
+
+class SecretShare:
+    def __init__(self, element, verbose_status=True):
+        self.elem = element
+        self.verbose = verbose_status
+        
+    def P(self, coeff, x):
+        share = 0
+        # evaluate polynomial
+        for i in range(0, len(coeff)):
+            share += (coeff[i] * (x ** i))
+        return share
+
+    def genShares(self, secret, k=0, n=0, q=None, x_points=None):
+        if(k <= n):
+            if q == None: 
+                q = [self.elem.random(ZR) for i in range(0, k)]
+                q[0] = secret
+
+            if x_points == None: # just go from 0 to n
+                shares = [self.P(q, i) for i in range(0, n+1)] # evaluating poly. q at i for all i
+            else:
+                shares = {}
+                for i in range(len(x_points)):
+                    shares[i] = (x_points[i], self.P(q, x_points[i]))
+#                     = [self.P(q, i) for i in x_points] # x_points should be a list
+
+        # debug
+        if self.verbose:
+            print('Secret: %s' % secret)
+            for i in range(1, k):
+                print("a %s: %s" % (i, q[i]))
+            print('')
+            if x_points == None:
+                for i in range(1,n+1):
+                    print('Share %s: %s' % (i, shares[i]))
+            else:
+                for i in range(len(x_points)):
+                    print('Share %s: %s' % (i, shares[i]))
+            
+        return shares
+    
+    # shares is a dictionary
+    def recoverCoefficients(self, list):
+        coeff = {}
+        for i in list:
+            result = 1
+            for j in list:
+                if not (i == j):
+                    # lagrange basis poly
+                    result *= (0 - j) / (i - j)
+            if self.verbose: print("coeff '%d' => '%s'" % (i, result))
+            coeff[i] = result
+        return coeff
+
+    # shares is a dictionary
+    def recoverCoefficientsDict(self, dict):
+        coeff = {}
+        for i in dict.values():
+            result = 1
+            for j in dict.values():
+                if not (i == j):
+                    # lagrange basis poly
+                    result *= (0 - j) / (i - j)
+            if self.verbose: print("coeff '%d' => '%s'" % (i, result))
+            coeff[i] = result
+        return coeff
+        
+    def recoverSecret(self, shares):
+        list = shares.keys()
+        if self.verbose: print(list)
+        coeff = self.recoverCoefficients(list)
+        if self.verbose: print("coefficients: ", coeff)
+        secret = 0
+        for i in list:
+            secret += (coeff[i] * shares[i])
+
+        return secret
+
+if __name__ == "__main__":
+
+# Testing Secret sharing python API
+  k = 3
+  n = 4
+  group = PairingGroup('SS512')
+
+  s = SecretShare(group, True)
+  sec = group.random(ZR)
+  shares = s.genShares(sec, k, n)
+
+  K = shares[0]
+  print('\nOriginal secret: %s' % K)
+  y = {group.init(ZR, 1):shares[1], group.init(ZR, 2):shares[2], group.init(ZR, 3):shares[3]}
+
+  secret = s.recoverSecret(y)
+
+  if(K == secret):
+    print('\nSuccessfully recovered secret: %s' % secret)
+  else:
+    print('\nCould not recover the secret!')
+
+