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

charm/toolbox/pairingcurves.py

@@ -0,0 +1,85 @@
+from charm.config import libs, pairing_lib
+
+a = """type a
+q 8780710799663312522437781984754049815806883199414208211028653399266475630880222957078625179422662221423155858769582317459277713367317481324925129998224791
+h 12016012264891146079388821366740534204802954401251311822919615131047207289359704531102844802183906537786776
+r 730750818665451621361119245571504901405976559617
+exp2 159
+exp1 107
+sign1 1
+sign0 1"""
+
+a1 = """type a1
+p 48512875896303752499712277254589628516419352188294521198189567511009073158115045361294839347099315898960045398524682007334164928531594799149100548036445760110913157420655690361891290858441360807158247259460501343449199712532828063940008683740048500980441989713739689655610578458388126934242630557397618776539259
+n 36203638728584889925158415861634051131656232976339194924022065306723188923966451762160327870969638730567198058600508960697138006366861790409776528385407283664860565239295291314844246909284597617282274074224254733917313218308080644731349763985110821627195514711746037056425804819692632040479575042834043863089
+l 1340
+"""
+
+d159 = """type d
+q 625852803282871856053922297323874661378036491717
+n 625852803282871856053923088432465995634661283063
+h 3
+r 208617601094290618684641029477488665211553761021
+a 581595782028432961150765424293919699975513269268
+b 517921465817243828776542439081147840953753552322
+k 6
+nk 60094290356408407130984161127310078516360031868417968262992864809623507269833854678414046779817844853757026858774966331434198257512457993293271849043664655146443229029069463392046837830267994222789160047337432075266619082657640364986415435746294498140589844832666082434658532589211525696
+hk 1380801711862212484403205699005242141541629761433899149236405232528956996854655261075303661691995273080620762287276051361446528504633283152278831183711301329765591450680250000592437612973269056
+coeff0 472731500571015189154958232321864199355792223347
+coeff1 352243926696145937581894994871017455453604730246
+coeff2 289113341693870057212775990719504267185772707305
+nqr 431211441436589568382088865288592347194866189652
+"""
+
+d201 = """type d
+q 2094476214847295281570670320144695883131009753607350517892357
+n 2094476214847295281570670320143248652598286201895740019876423
+h 1122591
+r 1865751832009427548920907365321162072917283500309320153
+a 9937051644888803031325524114144300859517912378923477935510
+b 6624701096592535354217016076096200573011941585948985290340
+k 6
+nk 84421409121513221644716967251498543569964760150943970280296295496165154657097987617093928595467244393873913569302597521196137376192587250931727762632568620562823714441576400096248911214941742242106512149305076320555351603145285797909942596124862593877499051211952936404822228308154770272833273836975042632765377879565229109013234552083886934379264203243445590336
+hk 24251848326363771171270027814768648115136299306034875585195931346818912374815385257266068811350396365799298585287746735681314613260560203359251331805443378322987677594618057568388400134442772232086258797844238238645130212769322779762522643806720212266304
+coeff0 362345194706722765382504711221797122584657971082977778415831
+coeff1 856577648996637037517940613304411075703495574379408261091623
+coeff2 372728063705230489408480761157081724912117414311754674153886
+nqr 279252656555925299126768437760706333663688384547737180929542
+"""
+
+d224 = """type d
+q 15028799613985034465755506450771565229282832217860390155996483840017
+n 15028799613985034465755506450771561352583254744125520639296541195021
+h 1
+r 15028799613985034465755506450771561352583254744125520639296541195021
+a 1871224163624666631860092489128939059944978347142292177323825642096
+b 9795501723343380547144152006776653149306466138012730640114125605701
+k 6
+nk 11522474695025217370062603013790980334538096429455689114222024912184432319228393204650383661781864806076247259556378350541669994344878430136202714945761488385890619925553457668158504202786580559970945936657636855346713598888067516214634859330554634505767198415857150479345944721710356274047707536156296215573412763735135600953865419000398920292535215757291539307525639675204597938919504807427238735811520
+hk 51014915936684265604900487195256160848193571244274648855332475661658304506316301006112887177277345010864012988127829655449256424871024500368597989462373813062189274150916552689262852603254011248502356041206544262755481779137398040376281542938513970473990787064615734720
+coeff0 11975189258259697166257037825227536931446707944682470951111859446192
+coeff1 13433042200347934827742738095249546804006687562088254057411901362771
+coeff2 8327464521117791238079105175448122006759863625508043495770887411614
+nqr 142721363302176037340346936780070353538541593770301992936740616924
+"""
+
+f254 = """type f
+q 16283262548997601220198008118239886027035269286659395419233331082106632227801
+r 16283262548997601220198008118239886026907663399064043451383740756301306087801
+b 7068387321767010428383604447141585855811153344588123938605766847051945009302
+beta 2144618501819208913782431868481640081004079749439232836584323016583030561512
+alpha0 386316900221926659979169226002672231458011916057040420493277182727499227585
+alpha1 12833444880567801377541563780933054992830992527850214079342609648119124982935
+"""
+
+# Notes: pbc library parameters : SS means super singular curve with the following digits 
+# represents the size of the base field in bits. MNT curves were created by 
+# Miyaji, Nakabayashi and Takano. BN curve was created by Barreto and Naehrig
+params = None
+if pairing_lib == libs.pbc:
+   params = {'SS512':a, 'SS1024':a1, 'MNT159':d159, 'MNT201':d201, 'MNT224':d224, 'BN254':f254 }
+elif pairing_lib == libs.miracl:
+   params = {'MNT160':80, 'BN256':128, 'SS512':80, 'SS1536':128}
+elif pairing_lib == libs.relic:
+   params = {'BN158':0, 'BN254':1, 'BN256':2}
+

charm/toolbox/pairinggroup.py

@@ -0,0 +1,186 @@
+try:
+  from charm.toolbox.pairingcurves import params as param_info
+  from charm.core.math.pairing import pairing,pc_element,ZR,G1,G2,GT,init,pair,hashPair,H,random,serialize,deserialize,ismember,order
+  import charm.core.math.pairing as pg
+  from charm.config import libs,pairing_lib
+except Exception as err:
+  raise ImportError("Cannot import pairing module. Ensure Charm crypto C extensions are compiled: %s" % err)
+
+class PairingGroup():
+    def __init__(self, param_id, param_file = False, secparam = 512, verbose = False, seed1 = None, seed2 = None):
+        #legacy handler to handle calls that still pass in a file path
+        if param_file:
+          self.Pairing = pairing(file=param_id)
+        elif type(param_id) == str:
+          pairID = param_info.get(param_id)
+          assert pairID != None, "'%s' not recognized! See 'pairingcurves.py' in toolbox." % param_id
+          if pairing_lib == libs.pbc:
+             self.Pairing = pairing(string=pairID)
+             self.param = param_id
+          elif pairing_lib in [libs.miracl, libs.relic]:
+             self.Pairing = pairing(pairID)
+             self.param = pairID
+        elif type(param_id) == int:
+          self.Pairing = pairing(param_id)
+          self.param   = param_id
+
+        """ the secure parameter $\\lambda$ should be a positive integer; otherwise, it may lead to computation errors in getting the message size """
+        assert isinstance(secparam, int) and secparam >= 1, "The security parameter $\\lambda$ should be a positive integer. "
+ 
+        self.secparam = secparam # number of bits
+        self._verbose = verbose
+        self.__gt = pair(self.random(G1, seed = seed1), self.random(G2, seed = seed2))
+    
+    def __str__(self):
+        return str(self.Pairing)
+
+    def order(self):
+        """returns the order of the group"""
+        return order(self.Pairing)
+    
+    def paramgen(self, qbits, rbits):
+        return None
+
+    def ismember(self, obj):
+        """membership test for a pairing object"""
+        return ismember(self.Pairing, obj)
+
+    def ismemberList(self, obj):
+        """membership test for a list of pairing objects"""        
+        for i in range(len(obj)):
+            if ismember(self.Pairing, obj[i]) == False: return False
+        return True
+
+    def ismemberDict(self, obj):
+        """membership test for a dict of pairing objects"""                
+        for i in obj.keys():
+            if ismember(self.Pairing, obj[i]) == False: return False
+        return True
+
+    def groupSetting(self):
+        return 'pairing'
+
+    def groupType(self): 
+        return self.param
+        
+    def messageSize(self):
+        """ after filling complete bytes with every 8 bits, any remaining 1, 2, ..., 7 more bits will occupy an additional byte, even if they do not form a complete byte """
+        return (self.secparam + 7) >> 3        
+
+    def init(self, type, value=None):
+        """initializes an object with a specified type and value""" 
+        if value != None:
+            return init(self.Pairing, type, value)
+        return init(self.Pairing, type)
+            
+    def random(self, _type = ZR, count = 1, seed = None):
+        """selects one or more random elements in ZR, G1, G2 and GT"""
+        if _type == GT:
+            if 1 == count:
+                return self.__gt ** (random(self.Pairing, ZR) if seed is None else random(self.Pairing, ZR, seed))
+            elif count >= 2:
+                return tuple(self.__gt ** random(self.Pairing, ZR) for _ in range(count))
+        elif _type in (ZR, G1, G2):
+            if 1 == count:
+                return random(self.Pairing, _type) if seed is None else random(self.Pairing, _type, seed)
+            elif count >= 2:
+                return tuple(random(self.Pairing, _type) for _ in range(count))
+        else:
+            return None
+    
+    def encode(self, message):
+        raise NotImplementedException
+    
+    def decode(self, element):
+        raise NotImplementedException 
+    
+    def hash(self, args, type=ZR):
+        """hashes objects into ZR, G1 or G2 depending on the pairing curve"""
+        return H(self.Pairing, args, type)
+    
+    def serialize(self, obj, compression=True):
+        """Serialize a pairing object into bytes.
+
+           :param compression: serialize the compressed representation of the
+                curve element, taking about half the space but potentially
+                incurring in non-negligible computation costs when
+                deserializing. Default is True for compatibility with previous
+                versions of charm.
+            
+            >>> p = PairingGroup('SS512')
+            >>> v1 = p.random(G1)
+            >>> b1 = p.serialize(v1)
+            >>> b1 == p.serialize(v1, compression=True)
+            True
+            >>> v1 == p.deserialize(b1)
+            True
+            >>> b1 = p.serialize(v1, compression=False)
+            >>> v1 == p.deserialize(b1, compression=False)
+            True
+        """
+        return serialize(obj, compression)
+    
+    def deserialize(self, obj, compression=True):
+        """Deserialize a bytes serialized element into a pairing object. 
+
+           :param compression: must be used for objects serialized with the
+                compression parameter set to True. Default is True for
+                compatibility with previous versions of charm.
+        """
+        return deserialize(self.Pairing, obj, compression)
+    
+    def debug(self, data, prefix=None):
+        if not self._verbose:
+            return
+        if type(data) == dict:
+            for k,v in data.items():
+               print(k,v)
+        elif type(data) == list:
+            for i in range(0, len(data)):
+               print(prefix, (i+1),':',data[i])
+            print('')
+        elif type(data) == str:
+            print(data)
+        else:
+            print(type(data), ':', data)
+        return
+    
+    def pair_prod(self, lhs, rhs):
+        """takes two lists of G1 & G2 and computes a pairing product"""
+        return pair(lhs, rhs, self.Pairing)
+
+    def InitBenchmark(self):
+        """initiates the benchmark state"""
+        return pg.InitBenchmark(self.Pairing)
+    
+    def StartBenchmark(self, options):
+        """starts the benchmark with any of these options: 
+        RealTime, CpuTime, Mul, Div, Add, Sub, Exp, Pair, Granular"""
+        return pg.StartBenchmark(self.Pairing, options)
+    
+    def EndBenchmark(self):
+        """ends an ongoing benchmark"""
+        return pg.EndBenchmark(self.Pairing)
+        
+    def GetGeneralBenchmarks(self):
+        """retrieves benchmark count for all group operations"""
+        return pg.GetGeneralBenchmarks(self.Pairing)
+    
+    def GetGranularBenchmarks(self):
+        """retrieves group operation count per type: ZR, G1, G2, and GT"""
+        return pg.GetGranularBenchmarks(self.Pairing)
+    
+    def GetBenchmark(self, option):
+        """retrieves benchmark results for any of these options: 
+        RealTime, CpuTime, Mul, Div, Add, Sub, Exp, Pair, Granular"""
+        return pg.GetBenchmark(self.Pairing, option)
+
+
+def extract_key(g):
+    """
+    Given a group element, extract a symmetric key
+    :param g:
+    :return:
+    """
+    g_in_hex = hashPair(g).decode('utf-8')
+    return bytes(bytearray.fromhex(g_in_hex))

charm/toolbox/policy_expression_spec.py

@@ -0,0 +1,70 @@
+from hypothesis.strategies import text, composite, sampled_from, characters, one_of, integers
+from functools import partial
+
+
+def policy_expressions_of_size(policy_expression_strategy, num_leaves):
+    if num_leaves == 1:
+        return one_of(attributes(), inequalities())
+    else:
+        return policy_expression_strategy(num_leaves)
+
+
+@composite
+def monotonic_policy_expression(draw, num_leaves):
+    left_leaves = draw(integers(min_value=1, max_value=num_leaves - 1))
+    right_leaves = num_leaves - left_leaves
+    left = draw(monotonic_policy_expressions_of_size(left_leaves))
+    right = draw(monotonic_policy_expressions_of_size(right_leaves))
+    gate = draw(gates())
+    return u'(' + u' '.join((left, gate, right)) + u')'
+
+
+@composite
+def alland_policy_expression(draw, num_leaves):
+    left_leaves = draw(integers(min_value=1, max_value=num_leaves - 1))
+    right_leaves = num_leaves - left_leaves
+    left = draw(alland_policy_expressions_of_size(left_leaves))
+    right = draw(alland_policy_expressions_of_size(right_leaves))
+    gate = draw(and_gates())
+    return u'(' + u' '.join((left, gate, right)) + u')'
+
+
+monotonic_policy_expressions_of_size = partial(policy_expressions_of_size, monotonic_policy_expression)
+alland_policy_expressions_of_size = partial(policy_expressions_of_size, alland_policy_expression)
+
+
+def policy_expressions(min_leaves=1, max_leaves=25):
+    return integers(min_leaves, max_leaves).flatmap(monotonic_policy_expressions_of_size)
+
+
+def alland_policy_expressions(min_leaves=1, max_leaves=25):
+    return integers(min_leaves, max_leaves).flatmap(alland_policy_expressions_of_size)
+
+
+def attributes():
+    return text(min_size=1, alphabet=characters(whitelist_categories='L', max_codepoint=0x7e))
+
+
+@composite
+def inequalities(draw):
+    attr = draw(attributes())
+    oper = draw(inequality_operators())
+    numb = draw(integers(min_value=1))
+    return u' '.join((attr, oper, str(numb)))
+
+
+def inequality_operators():
+    return sampled_from((u'<', u'>', u'<=', u'>='))
+
+
+def gates():
+    return sampled_from((u'or', u'and'))
+
+
+def and_gates():
+    return sampled_from((u'and',))
+
+
+def assert_valid(policy_expression):
+    assert policy_expression  # not empty
+    assert policy_expression.count(u'(') == policy_expression.count(u')')

charm/toolbox/policytree.py

@@ -0,0 +1,189 @@
+#!/usr/bin/python
+
+from pyparsing import *
+from charm.toolbox.node import *
+import string
+
+# Compatibility shim for pyparsing 2.x vs 3.x
+# pyparsing 3.0+ uses snake_case (set_parse_action)
+# pyparsing 2.x uses camelCase (setParseAction)
+# This wrapper ensures compatibility with both versions
+def _set_parse_action(parser_element, *fns, **kwargs):
+    """
+    Compatibility wrapper for setParseAction/set_parse_action.
+    Works with both pyparsing 2.x (camelCase) and 3.x (snake_case).
+    """
+    if hasattr(parser_element, 'set_parse_action'):
+        # pyparsing 3.x - use modern snake_case method
+        return parser_element.set_parse_action(*fns, **kwargs)
+    else:
+        # pyparsing 2.x - use legacy camelCase method
+        return parser_element.setParseAction(*fns, **kwargs)
+
+objStack = []
+
+def createAttribute(s, loc, toks):
+    if toks[0] == '!':
+        newtoks = ""
+        for i in toks:
+            newtoks += i
+        return BinNode(newtoks)
+    return BinNode(toks[0]) # create
+
+# convert 'attr < value' to a binary tree based on 'or' and 'and'
+def parseNumConditional(s, loc, toks):
+    print("print: %s" % toks)
+    return BinNode(toks[0])
+
+def printStuff(s, loc, toks):
+    print("print: %s" % toks)
+    return toks
+        
+def pushFirst( s, loc, toks ):
+    objStack.append( toks[0] )
+
+def createTree(op, node1, node2):
+    if(op == "or"):
+        node = BinNode(OpType.OR)
+    elif(op == "and"):
+        node = BinNode(OpType.AND)
+    else:
+        return None
+    node.addSubNode(node1, node2)
+    return node
+
+def downcaseTokens(s, loc, toks):
+    return [t.lower() for t in toks]
+
+class PolicyParser:
+    def __init__(self, verbose=False):
+        self.finalPol = self.getBNF()
+        self.verbose = verbose
+
+    def getBNF(self):
+        # supported operators => (OR, AND, <
+        OperatorOR = _set_parse_action(Literal("OR"), downcaseTokens) | Literal("or")
+        OperatorAND = _set_parse_action(Literal("AND"), downcaseTokens) | Literal("and")
+        Operator = OperatorAND | OperatorOR
+        lpar = Literal("(").suppress()
+        rpar = Literal(")").suppress()
+
+        BinOperator = Literal("<=") | Literal(">=") | Literal("==") | Word("<>", max=1)
+
+        # describes an individual leaf node
+        leafNode = _set_parse_action(Optional("!") + Word(alphanums+'-_./\\?!@#$^&*%'), createAttribute)
+        # describes expressions such as (attr < value)
+        leafConditional = _set_parse_action(Word(alphanums) + BinOperator + Word(nums), parseNumConditional)
+
+        # describes the node concept
+        node = leafConditional | leafNode
+
+        expr = Forward()
+        term = Forward()
+        atom = lpar + expr + rpar | _set_parse_action(node, pushFirst)
+        term = atom + ZeroOrMore(_set_parse_action(Operator + term, pushFirst))
+        expr << term + ZeroOrMore(_set_parse_action(Operator + term, pushFirst))
+        finalPol = expr  # could add: _set_parse_action(expr, printStuff)
+        return finalPol
+    
+    def evalStack(self, stack):
+        op = stack.pop()
+        if op in ["or", "and"]:
+            op2 = self.evalStack(stack)
+            op1 = self.evalStack(stack)
+            return createTree(op, op1, op2)
+        else:
+            # Node value (attribute)
+            return op
+    
+    def parse(self, string):
+        global objStack
+        del objStack[:]
+        # Use parse_string (pyparsing 3.x) or parseString (pyparsing 2.x)
+        if hasattr(self.finalPol, 'parse_string'):
+            self.finalPol.parse_string(string)
+        else:
+            self.finalPol.parseString(string)
+        return self.evalStack(objStack)
+
+    def findDuplicates(self, tree, _dict):
+        if tree.left: self.findDuplicates(tree.left, _dict)
+        if tree.right: self.findDuplicates(tree.right, _dict)
+        if tree.getNodeType() == OpType.ATTR:
+            key = tree.getAttribute()
+            if _dict.get(key) == None: _dict[ key ] = 1
+            else: _dict[ key ] += 1
+
+    def labelDuplicates(self, tree, _dictLabel):
+        if tree.left: self.labelDuplicates(tree.left, _dictLabel)
+        if tree.right: self.labelDuplicates(tree.right, _dictLabel)
+        if tree.getNodeType() == OpType.ATTR:
+            key = tree.getAttribute()
+            if _dictLabel.get(key) != None: 
+                tree.index = _dictLabel[ key ]
+                _dictLabel[ key ] += 1
+                
+    def prune(self, tree, attributes):
+        """given policy tree and attributes, determine whether the attributes satisfy the policy.
+           if not enough attributes to satisfy policy, return None otherwise, a pruned list of
+           attributes to potentially recover the associated secret.
+        """
+        (policySatisfied, prunedList) = self.requiredAttributes(tree, attributes)
+#        print("pruned attrs: ", prunedList)
+#        if prunedList:
+#            for i in prunedList:
+#                print("node: ", i)
+        if not policySatisfied:
+            return policySatisfied        
+        return prunedList
+
+    def requiredAttributes(self, tree, attrList):
+        """ determines the required attributes to satisfy policy tree and returns a list of BinNode
+        objects."""
+        if tree == None: return 0
+        Left = tree.getLeft()
+        Right = tree.getRight()
+        if Left: resultLeft, leftAttr = self.requiredAttributes(Left, attrList)
+        if Right: resultRight, rightAttr = self.requiredAttributes(Right, attrList)
+                
+        if(tree.getNodeType() == OpType.OR):
+            # never return both attributes, basically the first one that matches from left to right
+            if resultLeft: sendThis = leftAttr
+            elif resultRight: sendThis = rightAttr
+            else: sendThis = None
+
+            result = (resultLeft or resultRight)
+            if result == False: return (False, sendThis)            
+            return (True, sendThis)
+        if(tree.getNodeType() == OpType.AND):
+            if resultLeft and resultRight: sendThis = leftAttr + rightAttr
+            elif resultLeft: sendThis = leftAttr
+            elif resultRight: sendThis = rightAttr
+            else: sendThis = None
+
+            result = (resultLeft and resultRight)
+            if result == False: return (False, sendThis)
+            return (True, sendThis)
+            
+        elif(tree.getNodeType() == OpType.ATTR):
+            if(tree.getAttribute() in attrList):
+                return (True, [tree])
+            else:
+                return (False, None)
+            
+        return
+    
+if __name__ == "__main__":
+    # policy parser test cases 
+    parser = PolicyParser()
+    attrs = ['1', '3']
+    print("Attrs in user set: ", attrs)    
+    tree1 = parser.parse("(1 or 2) and (2 and 3))")
+    print("case 1: ", tree1, ", pruned: ", parser.prune(tree1, attrs))        
+    
+    tree2 = parser.parse("1 or (2 and 3)")
+    print("case 2: ", tree2, ", pruned: ", parser.prune(tree2, attrs))
+    
+    tree3 = parser.parse("(1 or 2) and (4 or 3)")
+    print("case 3: ", tree3, ", pruned: ", parser.prune(tree3, attrs))
+