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

charm/toolbox/hash_module.py

@@ -0,0 +1,91 @@
+import charm.core.crypto.cryptobase
+from charm.core.math.pairing import pairing,pc_element,ZR
+from charm.core.math.integer import integer,int2Bytes
+from charm.toolbox.conversion import Conversion
+from charm.toolbox.bitstring import Bytes
+import hashlib, base64
+
+class Hash():
+    def __init__(self, pairingElement=None, htype='sha256', integerElement=None):
+        self.hash_type = htype
+        # instance of PairingGroup
+        self.group = pairingElement
+        
+    def hashToZn(self, value):
+        if type(value) == pc_element:
+            h = hashlib.new(self.hash_type)
+            h.update(self.group.serialize(value))
+            #print "digest => %s" % h.hexdigest()
+            # get raw bytes of digest and hash to Zr
+            val = h.digest()
+            return integer(int(self.group.hash(val, ZR)))
+            # do something related to that
+        if type(value) == integer:
+            str_value = int2Bytes(value)
+            #print("str_value =>", str_value)
+            #val = self.group.hash(str_value, ZR)
+            #print("hash =>", val)
+            return integer(int(self.group.hash(str_value, ZR)))
+        return None
+    
+    # takes two arbitrary strings and hashes to an element of Zr
+    def hashToZr(self, *args):
+        if isinstance(args, tuple):
+            #print("Hashing =>", args)
+            strs = ""
+            for i in args:
+                if type(i) == str:
+                    strs += str(base64.encodebytes(bytes(i, 'utf8')))
+                elif type(i) == bytes:
+                    strs += str(base64.encodebytes(i))
+                elif type(i) == integer:
+                    strs += str(base64.encodebytes(int2Bytes(i)))
+                elif type(i) == pc_element:
+                    strs += str(base64.encodebytes(self.group.serialize(i)))
+
+            if len(strs) > 0:
+                return self.group.hash(strs, ZR)
+            return None
+        
+
+"""
+Waters Hash technique: how to hash in standard model.
+Default - len=8, bits=32 ==> 256-bits total (for SHA-256)
+For SHA1, len=5 bits=32 ==> 160-bits total
+"""
+class Waters:
+    """
+    >>> from charm.toolbox.pairinggroup import *
+    >>> from charm.toolbox.hash_module import Waters
+    >>> group = PairingGroup("SS512")
+    >>> waters = Waters(group, length=8, bits=32)
+    >>> a = waters.hash("user@email.com")
+    """
+    def __init__(self, group, length=8, bits=32, hash_func='sha256'):
+        self._group = group
+        self._length = length
+        self._bitsize = bits
+        self.hash_function = hash_func
+        self._hashObj = hashlib.new(self.hash_function)
+        self.hashLen = len(self._hashObj.digest())
+
+    def sha2(self, message):
+        h = self._hashObj.copy()
+        h.update(bytes(message, 'utf-8'))
+        return Bytes(h.digest())    
+    
+    def hash(self, strID):
+        '''Hash the identity string and break it up in to l bit pieces'''
+        assert type(strID) == str, "invalid input type"
+        hash = self.sha2(strID)
+        
+        val = Conversion.OS2IP(hash) #Convert to integer format
+        bstr = bin(val)[2:]   #cut out the 0b header
+
+        v=[]
+        for i in range(self._length):  #z must be greater than or equal to 1
+            binsubstr = bstr[self._bitsize*i : self._bitsize*(i+1)]
+            intval = int(binsubstr, 2)
+            intelement = self._group.init(ZR, intval)
+            v.append(intelement)
+        return v

charm/toolbox/integergroup.py

@@ -0,0 +1,323 @@
+try:
+  #from charm.core.math.integer import integer,randomBits,random,randomPrime,isPrime,encode,decode,hashInt,bitsize,legendre,gcd,lcm,serialize,deserialize,int2Bytes,toInt
+  from charm.core.math.integer import * #InitBenchmark,StartBenchmark,EndBenchmark,GetBenchmark,GetGeneralBenchmarks,ClearBenchmark
+  # Verify we got actual implementations, not mocks (for Sphinx autodoc)
+  _test = integer
+except Exception as err:
+  # Provide stub implementations for documentation purposes (Sphinx autodoc)
+  # These allow modules to be imported for documentation generation
+  # but will raise errors if actually used at runtime
+  class integer:
+      """Stub class for documentation. Requires C extension for actual use."""
+      pass
+  def randomBits(bits): raise NotImplementedError("Requires C extension")
+  def random(max): raise NotImplementedError("Requires C extension")
+  def randomPrime(bits, safe=False): raise NotImplementedError("Requires C extension")
+  def isPrime(n): raise NotImplementedError("Requires C extension")
+  def encode(M, p, q): raise NotImplementedError("Requires C extension")
+  def decode(element, p, q): raise NotImplementedError("Requires C extension")
+  def hashInt(args, p, q, flag): raise NotImplementedError("Requires C extension")
+  def bitsize(n): raise NotImplementedError("Requires C extension")
+  def legendre(a, p): raise NotImplementedError("Requires C extension")
+  def gcd(a, b): raise NotImplementedError("Requires C extension")
+  def lcm(a, b): raise NotImplementedError("Requires C extension")
+  def serialize(obj): raise NotImplementedError("Requires C extension")
+  def deserialize(data): raise NotImplementedError("Requires C extension")
+  def int2Bytes(n): raise NotImplementedError("Requires C extension")
+  def toInt(obj): raise NotImplementedError("Requires C extension")
+  def InitBenchmark(): raise NotImplementedError("Requires C extension")
+  def StartBenchmark(options): raise NotImplementedError("Requires C extension")
+  def EndBenchmark(): raise NotImplementedError("Requires C extension")
+  def GetBenchmark(option): raise NotImplementedError("Requires C extension")
+  def GetGeneralBenchmarks(): raise NotImplementedError("Requires C extension")
+  def ClearBenchmark(): raise NotImplementedError("Requires C extension")
+    
+class IntegerGroup:
+    def __init__(self, start=0):
+        pass
+
+    def setparam(self, p, q): 
+        if p == (2 * q) + 1 and isPrime(p) and isPrime(q):
+            self.p = integer(p)
+            self.q = integer(q)
+            return True
+        else:
+            print("p and q are not safe primes!")
+        return False
+    
+    def __str__(self):
+        outStr = ""
+        outStr += "p = " + str(self.p) + "\n"
+        outStr += "q = " + str(self.q) + "\n"
+        return outStr
+        
+    def paramgen(self, bits, r=2):
+        # determine which group
+        while True:
+            self.p = randomPrime(bits, 1)
+            self.q = (self.p - 1) / 2
+            if (isPrime(self.p) and isPrime(self.q)):
+                break
+        self.r = r
+        return None    
+    
+    def randomGen(self):
+        while True:
+            h = random(self.p)
+            g = (h ** self.r) % self.p
+            if not g == 1:
+                break
+        return g
+
+    def groupSetting(self):
+        return 'integer'
+        
+    def groupType(self): 
+        return 'SchnorrGroup mod p'     
+          
+    def groupOrder(self):
+        return bitsize(self.q)    
+    
+    def bitsize(self):    
+        return bitsize(self.q) / 8 
+    
+    def isMember(self, x):
+        return x.isCongruent()
+       
+    def random(self, max=0):
+        if max == 0:
+            return random(self.p)        
+        else:
+            return random(max)
+    
+    def encode(self, M):
+        return encode(M, self.p, self.q)
+     
+    def decode(self, element):
+        return decode(element, self.p, self.q)
+
+    def serialize(self, object):
+        assert type(object) == integer, "cannot serialize non-integer types"
+        return serialize(object)
+    
+    def deserialize(self, bytes_object):
+        assert type(bytes_object) == bytes, "cannot deserialize object"
+        return deserialize(bytes_object)
+    
+    def hash(self, *args):
+        if isinstance(args, tuple):
+            #print "Hashing => '%s'" % args
+            return hashInt(args, self.p, self.q, False)
+        return None
+
+    def InitBenchmark(self):
+        """initiates the benchmark state"""
+        return InitBenchmark()
+    
+    def StartBenchmark(self, options):
+        """starts the benchmark with any of these options: 
+        RealTime, CpuTime, Mul, Div, Add, Sub, Exp"""
+        return StartBenchmark(options)
+    
+    def EndBenchmark(self):
+        """ends an ongoing benchmark"""
+        return EndBenchmark()
+        
+    def GetGeneralBenchmarks(self):
+        """retrieves benchmark count for all group operations"""
+        return GetGeneralBenchmarks()
+        
+    def GetBenchmark(self, option):
+        """retrieves benchmark results for any of these options: 
+        RealTime, CpuTime, Mul, Div, Add, Sub, Exp"""
+        return GetBenchmark(option)
+
+class IntegerGroupQ:
+    def __init__(self, start=0):
+        pass
+
+    def __str__(self):
+        outStr = ""
+        outStr += "p = " + str(self.p) + "\n"
+        outStr += "q = " + str(self.q) + "\n"
+        return outStr
+
+    def setparam(self, p, q): 
+        if p == (2 * q) + 1 and isPrime(p) and isPrime(q):
+            self.p = integer(p)
+            self.q = integer(q)
+            return True
+        else:
+            print("p and q are not safe primes!")
+        return False
+        
+    def paramgen(self, bits, r=2):
+        # determine which group
+        while True:
+            self.p = randomPrime(bits, 1)
+            self.q = (self.p - 1) / 2
+            if (isPrime(self.p) and isPrime(self.q)):
+                break
+        self.r = r
+        return None    
+    
+    def randomG(self):
+        return self.randomGen()
+        
+    def randomGen(self):
+        while True:
+            h = random(self.p)
+            g = (h ** self.r) % self.p
+            if not g == 1:
+                #print "g => %s" % g 
+                break
+        return g
+
+    def groupSetting(self):
+        return 'integer'
+        
+    def groupType(self): 
+        return 'SchnorrGroup mod q'     
+          
+    def groupOrder(self):
+        return bitsize(self.q)    
+    
+    def messageSize(self):    
+        return bitsize(self.q) / 8 
+    
+    def isMember(self, x):
+        return x.isCongruent()
+       
+    def random(self, max=0):
+        if max == 0:
+            return random(self.q)
+        else:
+            return random(max)
+    
+    def encode(self, M):
+        return encode(M, self.p, self.q)
+     
+    def decode(self, element):
+        return decode(element, self.p, self.q)
+    
+    def hash(self, *args):
+        if isinstance(args, tuple):
+            return hashInt(args, self.p, self.q, True)
+        List = []
+        for i in args:
+            List.append(i)
+        return hashInt(tuple(List), self.p, self.q, True)
+
+    def serialize(self, object):
+        assert type(object) == integer, "cannot serialize non-integer types"
+        return serialize(object)
+    
+    def deserialize(self, bytes_object):
+        assert type(bytes_object) == bytes, "cannot deserialize object"
+        return deserialize(bytes_object)
+
+    def InitBenchmark(self):
+        """initiates the benchmark state"""
+        return InitBenchmark()
+    
+    def StartBenchmark(self, options):
+        """starts the benchmark with any of these options: 
+        RealTime, CpuTime, Mul, Div, Add, Sub, Exp"""
+        return StartBenchmark(options)
+    
+    def EndBenchmark(self):
+        """ends an ongoing benchmark"""
+        return EndBenchmark()
+        
+    def GetGeneralBenchmarks(self):
+        """retrieves benchmark count for all group operations"""
+        return GetGeneralBenchmarks()
+        
+    def GetBenchmark(self, option):
+        """retrieves benchmark results for any of these options: 
+        RealTime, CpuTime, Mul, Div, Add, Sub, Exp"""
+        return GetBenchmark(option)
+
+    
+class RSAGroup:
+    def __init__(self):
+        self.p = self.q = self.n = 0
+
+    def __str__(self):
+        outStr = ""
+        outStr += "p = " + str(self.p) + "\n"
+        outStr += "q = " + str(self.q) + "\n"
+        outStr += "N = " + str(self.n) + "\n"
+        return outStr
+    
+    def paramgen(self, secparam):
+        # Generate two random primes for RSA/Paillier
+        # Note: gcd(p*q, (p-1)*(q-1)) is always 1 for distinct primes p, q
+        # so we don't need to check that condition
+        p, q = randomPrime(secparam), randomPrime(secparam)
+        n = p * q
+        self.p = p
+        self.q = q
+        self.n = n
+        return (p, q, n)
+
+    def setparam(self, p, q): 
+        if isPrime(p) and isPrime(q) and p != q:
+            self.p = integer(p)
+            self.q = integer(q)
+            self.n = self.p * self.q
+            return True
+        else:
+            print("p and q are not primes!")
+        return False
+
+    def serialize(self, object):
+        assert type(object) == integer, "cannot serialize non-integer types"
+        return serialize(object)
+    
+    def deserialize(self, bytes_object):
+        assert type(bytes_object) == bytes, "cannot deserialize object"
+        return deserialize(bytes_object)
+
+    def random(self, max=0):
+        if max == 0:
+            return random(self.n)        
+        else:
+            return random(max)
+
+    def groupSetting(self):
+        return 'integer'
+
+    def groupType(self): 
+        return 'RSAGroup mod p'     
+          
+    def groupOrder(self):
+        return bitsize(self.n)    
+        
+    def encode(self, value):
+        pass
+
+    def decode(self, value):
+        pass
+
+    def InitBenchmark(self):
+        """initiates the benchmark state"""
+        return InitBenchmark()
+    
+    def StartBenchmark(self, options):
+        """starts the benchmark with any of these options: 
+        RealTime, CpuTime, Mul, Div, Add, Sub, Exp"""
+        return StartBenchmark(options)
+    
+    def EndBenchmark(self):
+        """ends an ongoing benchmark"""
+        return EndBenchmark()
+        
+    def GetGeneralBenchmarks(self):
+        """retrieves benchmark count for all group operations"""
+        return GetGeneralBenchmarks()
+        
+    def GetBenchmark(self, option):
+        """retrieves benchmark results for any of these options: 
+        RealTime, CpuTime, Mul, Div, Add, Sub, Exp"""
+        return GetBenchmark(option)

charm/toolbox/iterate.py

@@ -0,0 +1,22 @@
+
+# simple example
+#>>> a = [1,2,3,4,5]
+#>>> dotprod(1, 1, len(a), lambda i,b: (b[i] ** 2), a)
+# TODO: support caching of values at each stage of product?
+
+def dotprod(init, skip, n, func, *args):
+    prod = init
+    i = 0 
+    for j in range(i, n):
+        if j != skip:
+           result = func(j, *args)
+           # cache if necessary
+           prod *= result
+    #print("product =>", prod)
+    return prod
+
+def dotprod2(iterator, func, *args):
+    prod = 1
+    for j in iterator:
+        prod *= func(j, *args)
+    return prod

charm/toolbox/matrixops.py

@@ -0,0 +1,76 @@
+
+'''
+:Authors:    Fan Zhang(zfwise@gwu.edu), supported by GWU computer science department
+:Date:       3/2013
+:Note: Matrix operations over finite fields
+'''
+def GaussEliminationinGroups(m):
+    #The code was original found at: http://ine.scripts.mit.edu/blog/2011/05/gaussian-elimination-in-python/
+    #Here is an example: suppose you have A= [[1,2],
+    #                                        [3,4]]
+    #and you want AX = I.
+    #if X = [[x1,x2],[x3,x4]] and I = [[1,0],[0,1]]
+    #GaussEliminationinGroups([1,2,1],[3,4,0])-->[x1,x3]
+    #GaussEliminationinGroups([1,2,0],[3,4,1])-->[x2,x4]
+    #then X = MatrixTransGroups[[x1,x3],[x2,x4]]
+    
+    #eliminate columns
+    for col in range(len(m[0])):
+        for row in range(col+1, len(m)):
+            r = [(rowValue * (-(m[row][col] / m[col][col]))) for rowValue in m[col]]
+            m[row] = [ (pair[0]+pair[1]) for pair in zip(m[row], r)]
+    #now backsolve by substitution
+    ans = []
+    m.reverse() #makes it easier to backsolve
+    for sol in range(len(m)):
+            if sol == 0:
+                ans.append(m[sol][-1] / m[sol][-2])
+            else:
+                inner = 0
+                #substitute in all known coefficients
+                for x in range(sol):
+                    inner += (ans[x]*m[sol][-2-x])
+                #the equation is now reduced to ax + b = c form
+                #solve with (c - b) / a
+                ans.append((m[sol][-1]-inner)/m[sol][-sol-2])
+    ans.reverse()
+    return ans
+
+def MatrixMulGroups(matrix1,matrix2):
+    # Matrix multiplication
+    if len(matrix1[0]) != len(matrix2):
+        # Check matrix dimensions
+        print('Matrices must be m*n and n*p to multiply!')
+    else:
+        # Multiply if correct dimensions
+        new_matrix = [[0 for row in range(len(matrix2[0]))] for col in range(len(matrix1))]
+        for i in range(len(matrix1)):
+            for j in range(len(matrix2[0])):
+                for k in range(len(matrix2)):
+                    new_matrix[i][j] += matrix1[i][k]*matrix2[k][j]
+    return new_matrix
+
+def MatrixAddGroups(matrix1,matrix2):
+    # Matrix Addition
+    if (len(matrix1[0]) != len(matrix2[0]) or len(matrix1) != len(matrix2)):
+        # Check matrix dimensions
+        print('Matrices must be m*m and m*m to Add!')
+    else:
+        # Add if correct dimensions
+        rows = len(matrix1)
+        columns =len(matrix1[0])
+        result = [[matrix1[row][col] + matrix2[row][col] for col in range(columns)] for row in range(rows)]
+    return result
+
+def MatrixScalarMulGroups(lamda , matrix):
+    # Matrix Scalar Mul
+    rows = len(matrix)
+    columns =len(matrix[0])
+    result = [[matrix[row][col] * lamda for col in range(columns)] for row in range(rows)]
+    return result
+
+def MatrixTransGroups(matrix):
+    # Matrix transpose, 
+    result = [[r[col] for r in matrix] for col in range(len(matrix[0]))]
+    return result
+