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

charm/toolbox/Hash.py

@@ -0,0 +1,39 @@
+from charm.toolbox.schemebase import *
+
+class Hash(SchemeBase):
+    ''' Base class for Hash functions
+
+    Notes: This class implements an interface for a standard hash function scheme.
+    A hash function consists of two algorithms: (paramgen or keygen and hash).
+    '''
+    
+    def __init__(self):
+        SchemeBase.__init__(self)
+        SchemeBase._setProperty(self, scheme='Hash')
+        self.baseSecDefs = None # Enum('EU_CMA')
+    # base methods?
+    def paramgen(self, *args):
+        raise NotImplementedError
+    
+    def hash(self, *args):
+        raise NotImplementedError
+
+
+class ChamHash(Hash):
+    '''
+    Notes: This class implements an interface for a chameleon hash function. 
+    A standard charmeleon hash scheme has two algorithms paramgen and hash.
+    paramgen accepts a security parameter and the length of p and q. Hash accepts
+    public key, label, a message and a random element.
+    '''
+    
+    def __init__(self):
+        Hash.__init__(self)
+        Hash._setProperty(self, scheme='ChamHash')
+        self.baseSecDefs = None # Enum('EU_CMA')
+        
+    def paramgen(self, secparam, p=None, q=None):
+        raise NotImplementedError		
+
+    def hash(self, pk, prefix, message, r):
+        raise NotImplementedError

charm/toolbox/IBEnc.py

@@ -0,0 +1,62 @@
+'''
+Base class for identity-based encryption
+ 
+ Notes: This class implements an interface for a standard identity-based encryption scheme.
+        Identity-based encryption consists of three algorithms: (setup, extract, encrypt, and decrypt).
+'''
+from charm.toolbox.schemebase import *
+
+ibeBaseSecDefs = Enum('IND_ID_CPA','IND_sID_CPA','IND_ID_CCA','IND_sID_CCA', 'IND_ID_CCA2')
+IND_ID_CPA,IND_sID_CPA,IND_ID_CCA,IND_sID_CCA,IND_ID_CCA2='IND_ID_CPA','IND_sID_CPA','IND_ID_CCA','IND_sID_CCA', 'IND_ID_CCA2'
+
+ibeSchemeType='ibeScheme'
+
+class IBEnc(SchemeBase):
+    def __init__(self):
+        SchemeBase.__init__(self)
+        SchemeBase._setProperty(self, scheme='IBEnc')
+    
+    def setProperty(self, secDef=None, assumption=None, messageSpace=None, secModel=None, **kwargs):
+        assert secDef is not None and secDef in ibeBaseSecDefs.getList(), "not a valid security definition for this scheme type."
+        SchemeBase._setProperty(self, None, ibeBaseSecDefs[secDef], str(assumption), messageSpace, str(secModel), **kwargs)
+        return True
+    
+    def getProperty(self):
+        baseProp = SchemeBase._getProperty(self)
+        return baseProp
+    
+    def checkProperty(self, schemeObj, _reqProps):
+        reqProps = [ (str(k), str(v)) for k,v in _reqProps ]
+        result = SchemeBase._checkProperty(self, schemeObj, reqProps)
+        return result
+
+    def updateProperty(self, scheme, secDef=None, assumption=None, messageSpace=None, secModel=None, **kwargs):
+        # 1. inherit the scheme's properties
+        assert hasattr(scheme, 'properties'), "schemeObj does not have getProperty() method."
+        self.properties.update(scheme.getProperty())
+        # 2. make sure things are consistent, then update to new properties
+        assert self.properties[schemeType] is not None, "scheme type wasn't specified on initialization"
+        assert secDef is not None and secDef in ibeBaseSecDefs.getList(), "not a valid security definition for this scheme type."
+        SchemeBase._setProperty(self, None, ibeBaseSecDefs[secDef], str(assumption), messageSpace, str(secModel), **kwargs)
+        return
+
+    def printProperties(self):
+        name = str(self.__class__).split("'")[-2].split(".")[-1]
+        print("<=== %s Properties ===>" % name)
+        for k,v in self.properties.items():
+            print(k, ":", v)
+        print("<=== %s Properties ===>" % name)            
+        return
+    
+    def setup(self):
+        raise NotImplementedError
+    
+    def extract(self, mk, ID):
+        raise NotImplementedError
+    
+    def encrypt(self, pk, ID, message):
+        raise NotImplementedError
+    
+    def decrypt(self, pk, sk, ct):
+        raise NotImplementedError
+        

charm/toolbox/IBSig.py

@@ -0,0 +1,64 @@
+'''
+Base class for identity-based signatures
+ 
+ Notes: This class implements an interface for a standard identity-based signatures scheme.
+        Identity-based signatures consists of four algorithms: (setup, keygen, sign and verify).
+'''
+from charm.toolbox.schemebase import *
+
+ibsigBaseSecDefs = Enum('EU_CMA', 'wEU_CMA', 'sEU_CMA')
+EU_CMA,wEU_CMA,sEU_CMA="EU_CMA","wEU_CMA","sEU_CMA"
+
+ibsigSchemeType='ibsigScheme'
+
+class IBSig(SchemeBase):
+    def __init__(self):
+        SchemeBase.__init__(self)
+        SchemeBase._setProperty(self, scheme='IBSig')
+    
+    def setProperty(self, secDef=None, assumption=None, messageSpace=None, secModel=None, **kwargs):
+        assert secDef is not None and secDef in ibsigBaseSecDefs.getList(), "not a valid security definition for this scheme type."
+        SchemeBase._setProperty(self, None, ibsigBaseSecDefs[secDef], str(assumption), messageSpace, str(secModel), **kwargs)
+        return True
+    
+    def getProperty(self):
+        baseProp = SchemeBase._getProperty(self)
+        return baseProp
+    
+    def checkProperty(self, schemeObj, _reqProps):
+        reqProps = [ (str(k), str(v)) for k,v in _reqProps ]
+        result = SchemeBase._checkProperty(self, schemeObj, reqProps)
+        if result == True:
+            self.setScheme(schemeObj)
+        return result
+
+    def updateProperty(self, scheme, secDef=None, assumption=None, messageSpace=None, secModel=None, **kwargs):
+        # 1. inherit the scheme's properties
+        assert hasattr(scheme, 'properties'), "schemeObj does not have getProperty() method."
+        self.properties.update(scheme.getProperty())
+        # 2. make sure things are consistent, then update to new properties
+        assert self.properties[schemeType] is not None, "scheme type wasn't specified on initialization"
+        assert secDef is not None and secDef in ibsigBaseSecDefs.getList(), "not a valid security definition for this scheme type."
+        SchemeBase._setProperty(self, None, ibsigBaseSecDefs[secDef], str(assumption), messageSpace, str(secModel), **kwargs)
+        return
+
+    def printProperties(self):
+        name = str(self.__class__).split("'")[-2].split(".")[-1]
+        print("<=== %s Properties ===>" % name)
+        for k,v in self.properties.items():
+            print(k, ":", v)
+        print("<=== %s Properties ===>" % name)            
+        return
+    
+    def setup(self):
+        raise NotImplementedError
+    
+    def keygen(self, msk, ID):
+        raise NotImplementedError
+    
+    def sign(self, pk, sk, M):
+        raise NotImplementedError
+    
+    def verify(self, pk, M, sig):
+        raise NotImplementedError
+        

charm/toolbox/PKEnc.py

@@ -0,0 +1,66 @@
+'''
+Base class for public-key encryption
+ 
+Notes: This class implements an interface for a standard public-key encryption scheme.
+A public key encryption consists of four algorithms: (paramgen, keygen, encrypt, decrypt).
+'''
+from charm.toolbox.schemebase import *
+
+encBaseSecDefs = Enum('OW_CPA','OW_CCA1','OW_CCA','IND_CPA','IND_CCA1','IND_CCA',
+                    'NM_CPA','NM_CCA1','NM_CCA','KA_CPA','KA_CCA1','KA_CCA')
+
+OW_CPA,OW_CCA1,OW_CCA="OW_CPA","OW_CCA1","OW_CCA"
+IND_CPA,IND_CCA1,IND_CCA="IND_CPA","IND_CCA1","IND_CCA"
+NM_CPA,NM_CCA1,NM_CCA="NM_CPA","NM_CCA1","NM_CCA"
+KA_CPA,KA_CCA1,KA_CCA='KA_CPA','KA_CCA1','KA_CCA'
+
+pkencSchemeType="pkeScheme"
+
+class PKEnc(SchemeBase):
+    def __init__(self):
+        SchemeBase.__init__(self)
+        SchemeBase._setProperty(self, scheme='PKEnc')
+    
+    def setProperty(self, secDef=None, assumption=None, messageSpace=None, secModel=None, **kwargs):
+        assert secDef is not None and secDef in encBaseSecDefs.getList(), "not a valid security definition for this scheme type."
+        SchemeBase._setProperty(self, None, encBaseSecDefs[secDef], str(assumption), messageSpace, str(secModel), **kwargs)
+        return True
+    
+    def getProperty(self):
+        baseProp = SchemeBase._getProperty(self)
+        return baseProp
+    
+    def checkProperty(self, schemeObj, _reqProps):
+        reqProps = [ (str(k), str(v)) for k,v in _reqProps ]
+        result = SchemeBase._checkProperty(self, schemeObj, reqProps)
+        return result
+
+    def updateProperty(self, scheme, secDef=None, assumption=None, messageSpace=None, secModel=None, **kwargs):
+        # 1. inherit the scheme's properties
+        assert hasattr(scheme, 'properties'), "schemeObj does not have getProperty() method."
+        self.properties.update(scheme.getProperty())
+        # 2. make sure things are consistent, then update to new properties
+        assert self.properties[schemeType] is not None, "scheme type wasn't specified on initialization"
+        assert secDef is not None and secDef in encBaseSecDefs.getList(), "not a valid security definition for this scheme type."
+        SchemeBase._setProperty(self, None, encBaseSecDefs[secDef], str(assumption), messageSpace, str(secModel), **kwargs)
+        return
+
+    def printProperties(self):
+        name = str(self.__class__).split("'")[-2].split(".")[-1]
+        print("<=== %s Properties ===>" % name)
+        for k,v in self.properties.items():
+            print(k, ":", v)
+        print("<=== %s Properties ===>" % name)            
+        return
+    
+    def paramgen(self, param1=None, param2=None):
+        return NotImplemented
+
+    def keygen(self, securityparam):
+        return NotImplemented
+
+    def encrypt(self, pk, M):
+        return NotImplemented
+
+    def decrypt(self, pk, sk, c):
+        return NotImplemented

charm/toolbox/PKSig.py

@@ -0,0 +1,56 @@
+'''
+Base class for public-key signatures
+ 
+Notes: This class implements an interface for a standard public-key signature scheme.
+A public key signature consists of three algorithms: (keygen, sign, verify).
+'''
+from charm.toolbox.schemebase import *
+
+pksigBaseSecDefs = Enum('EU_CMA', 'wEU_CMA', 'sEU_CMA')
+EU_CMA,wEU_CMA,sEU_CMA="EU_CMA","wEU_CMA","sEU_CMA"
+
+class PKSig(SchemeBase):
+    def __init__(self):
+        SchemeBase.__init__(self)
+        SchemeBase._setProperty(self, scheme='PKSig')
+    
+    def setProperty(self, secDef=None, assumption=None, messageSpace=None, secModel=None, **kwargs):
+        assert secDef is not None and secDef in pksigBaseSecDefs.getList(), "not a valid security definition for this scheme type."
+        SchemeBase._setProperty(self, None, pksigBaseSecDefs[secDef], str(assumption), messageSpace, str(secModel), **kwargs)
+        return True
+    
+    def getProperty(self):
+        baseProp = SchemeBase._getProperty(self)
+        return baseProp
+    
+    def checkProperty(self, schemeObj, _reqProps):
+        reqProps = [ (str(k), str(v)) for k,v in _reqProps ]
+        result = SchemeBase._checkProperty(self, schemeObj, reqProps)
+        return result
+
+    def updateProperty(self, scheme, secDef=None, assumption=None, messageSpace=None, secModel=None, **kwargs):
+        # 1. inherit the scheme's properties
+        assert hasattr(scheme, 'properties'), "schemeObj does not have getProperty() method."
+        self.properties.update(scheme.getProperty())
+        # 2. make sure things are consistent, then update to new properties
+        assert self.properties[schemeType] is not None, "scheme type wasn't specified on initialization"
+        assert secDef is not None and secDef in pksigBaseSecDefs.getList(), "not a valid security definition for this scheme type."
+        SchemeBase._setProperty(self, None, pksigBaseSecDefs[secDef], str(assumption), messageSpace, str(secModel), **kwargs)
+        return
+
+    def printProperties(self):
+        name = str(self.__class__).split("'")[-2].split(".")[-1]
+        print("<=== %s Properties ===>" % name)
+        for k,v in self.properties.items():
+            print(k, ":", v)
+        print("<=== %s Properties ===>" % name)            
+        return
+    
+    def keygen(self, securityparam):
+        raise NotImplementedError		
+
+    def sign(self, pk, sk, message):
+        raise NotImplementedError
+    
+    def verify(self, pk, message, sig):
+        raise NotImplementedError

charm/toolbox/PREnc.py

@@ -0,0 +1,32 @@
+''' Base class for Proxy Re-Encryption
+ 
+ Notes: This class implements an interface for a standard proxy re-encryption scheme.
+ 
+ A proxy re-encryption scheme consists of six algorithms: 
+ (setup, keygen, encrypt, decrypt, rekeygen, re_encrypt).
+'''
+from charm.toolbox.schemebase import *
+
+class PREnc(SchemeBase):
+    def __init__(self):
+        SchemeBase.__init__(self)
+        SchemeBase._setProperty(self, scheme='PREnc')  
+        #self.baseSecDefs = Enum('IND_AB_CPA', 'IND_AB_CCA', 'sIND_AB_CPA', 'sIND_AB_CCA') 
+
+    def setup(self):
+        raise NotImplementedError
+
+    def keygen(self, params):
+        raise NotImplementedError
+
+    def encrypt(self, params, pk, M):
+        raise NotImplementedError
+
+    def decrypt(self, params, sk, ct):
+        raise NotImplementedError
+
+    def rekeygen(self, params, pk_a, sk_a, pk_b, sk_b):
+        raise NotImplementedError
+    
+    def re_encrypt(self, params, rk, c_a):
+        raise NotImplementedError

charm/toolbox/ZKProof.py

@@ -0,0 +1,289 @@
+"""
+Base class for Zero-Knowledge Proof systems.
+
+This module provides a base class for implementing zero-knowledge proof schemes
+in the Charm cryptographic library. Zero-knowledge proofs allow a prover to
+convince a verifier that a statement is true without revealing any additional
+information beyond the validity of the statement.
+
+The module defines:
+    - Security definitions for ZK proofs (HVZK, ZK, NIZK, SIM)
+    - Exception classes for error handling
+    - ZKProofBase class for implementing concrete ZK proof schemes
+    - Proof dataclass for storing proof components
+
+Security Properties:
+    - HVZK: Honest-Verifier Zero-Knowledge - secure against honest verifiers
+    - ZK: Zero-Knowledge - secure against malicious verifiers
+    - NIZK: Non-Interactive Zero-Knowledge - no interaction required
+    - SIM: Simulation Sound - proofs cannot be simulated without witness
+
+Example:
+    class SchnorrProof(ZKProofBase):
+        def setup(self, group):
+            # Initialize with the group
+            ...
+        def prove(self, statement, witness):
+            # Generate Schnorr proof
+            ...
+        def verify(self, statement, proof):
+            # Verify Schnorr proof
+            ...
+"""
+from charm.toolbox.schemebase import *
+from charm.toolbox.enum import *
+from dataclasses import dataclass
+from typing import Any, Optional
+
+# Security definitions for zero-knowledge proofs
+zkpSecDefs = Enum('HVZK', 'ZK', 'NIZK', 'SIM')
+HVZK, ZK, NIZK, SIM = "HVZK", "ZK", "NIZK", "SIM"
+
+
+class ZKProofError(Exception):
+    """Base exception for the ZKP module.
+    
+    All ZKP-related exceptions inherit from this class, allowing
+    for broad exception catching when needed.
+    """
+    pass
+
+
+class ZKParseError(ZKProofError):
+    """Error parsing ZK statements.
+    
+    Raised when a zero-knowledge statement cannot be parsed,
+    typically due to malformed input or invalid syntax.
+    """
+    pass
+
+
+class ZKValidationError(ZKProofError):
+    """Error validating inputs.
+    
+    Raised when inputs to ZKP operations fail validation,
+    such as invalid group elements or malformed witnesses.
+    """
+    pass
+
+
+class ZKProofVerificationError(ZKProofError):
+    """Proof verification failed.
+    
+    Raised when a zero-knowledge proof fails verification,
+    indicating either an invalid proof or mismatched statement.
+    """
+    pass
+
+
+@dataclass
+class Proof:
+    """Dataclass to hold zero-knowledge proof components.
+    
+    This class encapsulates all components of a zero-knowledge proof,
+    following the standard Sigma protocol structure (commitment, challenge, response).
+    
+    Attributes:
+        commitment: The prover's initial commitment value(s). This is the first
+            message in a Sigma protocol, committing the prover to random values.
+        challenge: The challenge value from the verifier (or derived via Fiat-Shamir
+            for non-interactive proofs). Must be unpredictable to the prover.
+        response: The prover's response computed using the witness and challenge.
+            This allows the verifier to check the proof without learning the witness.
+        proof_type: String identifier for the type of proof (e.g., 'schnorr', 'dleq',
+            'or', 'and'). Used for deserialization and validation.
+        version: Integer version number for the proof format. Allows for backward
+            compatibility when proof formats evolve.
+    
+    Example:
+        proof = Proof(
+            commitment=g ** r,
+            challenge=hash(commitment, statement),
+            response=r + challenge * secret,
+            proof_type='schnorr',
+            version=1
+        )
+    """
+    commitment: Any
+    challenge: Any
+    response: Any
+    proof_type: str
+    version: int = 1
+
+
+class ZKProofBase(SchemeBase):
+    """Base class for zero-knowledge proof schemes.
+    
+    This class provides the foundation for implementing zero-knowledge proof
+    systems in Charm. Concrete implementations should extend this class and
+    implement all abstract methods.
+    
+    A zero-knowledge proof scheme consists of three core algorithms:
+        - setup: Initialize the proof system with group parameters
+        - prove: Generate a proof that a statement is true given a witness
+        - verify: Verify that a proof is valid for a given statement
+    
+    Additionally, serialization methods are provided for proof persistence
+    and network transmission.
+    
+    Security Properties:
+        Implementations should specify their security level using setProperty():
+        - HVZK: Secure against honest verifiers only
+        - ZK: Secure against malicious verifiers (requires simulation)
+        - NIZK: Non-interactive (typically via Fiat-Shamir transform)
+        - SIM: Simulation soundness (proofs unforgeable even with simulated proofs)
+    
+    Example:
+        class MyZKProof(ZKProofBase):
+            def __init__(self):
+                ZKProofBase.__init__(self)
+                self.setProperty(secDef='NIZK', assumption='DL', secModel='ROM')
+    """
+    
+    def __init__(self):
+        """Initialize the ZKProof base class.
+
+        Calls the parent SchemeBase constructor and sets the scheme type
+        to 'ZKProof' for property tracking and type checking.
+        """
+        SchemeBase.__init__(self)
+        SchemeBase._setProperty(self, scheme='ZKProof')
+
+    def setProperty(self, secDef=None, assumption=None, messageSpace=None, secModel=None, **kwargs):
+        """Set security properties for this ZK proof scheme.
+
+        Configures the security properties of the proof scheme, including
+        the security definition, hardness assumption, and security model.
+
+        Args:
+            secDef: Security definition, must be one of: 'HVZK', 'ZK', 'NIZK', 'SIM'.
+                Defines the zero-knowledge security level of the scheme.
+            assumption: The computational hardness assumption (e.g., 'DL', 'DDH').
+                Should be a string representing the underlying assumption.
+            messageSpace: Description of the valid message/statement space.
+                Can be a type or list of types.
+            secModel: Security model, typically 'SM' (standard), 'ROM' (random oracle),
+                or 'CRS' (common reference string).
+            **kwargs: Additional scheme-specific properties.
+
+        Returns:
+            bool: True if properties were set successfully.
+
+        Raises:
+            AssertionError: If secDef is not a valid security definition.
+        """
+        assert secDef is not None and secDef in zkpSecDefs.getList(), \
+            "not a valid security definition for this scheme type."
+        SchemeBase._setProperty(self, None, zkpSecDefs[secDef], str(assumption),
+                                messageSpace, str(secModel), **kwargs)
+        return True
+
+    def getProperty(self):
+        """Get the security properties of this ZK proof scheme.
+
+        Returns:
+            dict: A dictionary containing all configured security properties,
+                including scheme type, security definition, assumption,
+                message space, and security model.
+        """
+        baseProp = SchemeBase._getProperty(self)
+        return baseProp
+
+    def setup(self, group):
+        """Initialize the proof system with group parameters.
+
+        This method should initialize any scheme-specific parameters
+        needed for proof generation and verification.
+
+        Args:
+            group: The algebraic group to use for the proof system.
+                Typically a pairing group or integer group from Charm.
+
+        Returns:
+            Implementation-specific setup parameters (e.g., public parameters).
+
+        Raises:
+            NotImplementedError: Must be implemented by subclasses.
+        """
+        raise NotImplementedError
+
+    def prove(self, statement, witness):
+        """Generate a zero-knowledge proof.
+
+        Creates a proof that the prover knows a witness satisfying the
+        given statement, without revealing the witness itself.
+
+        Args:
+            statement: The public statement to prove. The format depends
+                on the specific proof type (e.g., public key for Schnorr).
+            witness: The secret witness known only to the prover
+                (e.g., private key for Schnorr).
+
+        Returns:
+            Proof: A Proof object containing commitment, challenge, and response.
+
+        Raises:
+            NotImplementedError: Must be implemented by subclasses.
+            ZKValidationError: If statement or witness validation fails.
+        """
+        raise NotImplementedError
+
+    def verify(self, statement, proof):
+        """Verify a zero-knowledge proof.
+
+        Checks whether the given proof is valid for the statement,
+        confirming that the prover knows a valid witness.
+
+        Args:
+            statement: The public statement that was proven.
+            proof: The Proof object to verify.
+
+        Returns:
+            bool: True if the proof is valid, False otherwise.
+
+        Raises:
+            NotImplementedError: Must be implemented by subclasses.
+            ZKValidationError: If statement or proof format is invalid.
+            ZKProofVerificationError: If verification fails due to invalid proof.
+        """
+        raise NotImplementedError
+
+    def serialize(self, proof, group):
+        """Serialize a proof to bytes.
+
+        Converts a Proof object to a byte representation suitable for
+        storage or network transmission.
+
+        Args:
+            proof: The Proof object to serialize.
+            group: The algebraic group used in the proof, needed for
+                serializing group elements.
+
+        Returns:
+            bytes: The serialized proof data.
+
+        Raises:
+            NotImplementedError: Must be implemented by subclasses.
+            ZKValidationError: If proof format is invalid for serialization.
+        """
+        raise NotImplementedError
+
+    def deserialize(self, data, group):
+        """Deserialize bytes to a proof.
+
+        Reconstructs a Proof object from its byte representation.
+
+        Args:
+            data: The serialized proof bytes.
+            group: The algebraic group used in the proof, needed for
+                deserializing group elements.
+
+        Returns:
+            Proof: The reconstructed Proof object.
+
+        Raises:
+            NotImplementedError: Must be implemented by subclasses.
+            ZKParseError: If the data cannot be parsed as a valid proof.
+        """
+        raise NotImplementedError
+

charm/toolbox/bitstring.py

@@ -0,0 +1,49 @@
+'''
+``bistring.Bytes`` is a replacement for Python's ``byte``.
+'''
+
+import string
+import sys
+
+py3 = False
+if float(sys.version[:3]) >= 3.0:
+    py3 = True
+
+
+class Bytes(bytes):
+    def __init__(self, value, enc=None):
+        if enc != None:
+           if py3: bytes.__init__(value, enc)
+           else: bytes.__init__(value)
+        else:
+           bytes.__init__(value)
+
+    def __xor__(self, other):
+        '''Overload the ``^`` operator to provide xor '''
+        assert len(self) == len(other), "xor: operands differ in length."
+        res = bytearray()
+        for i in range(0,len(self)):
+            if py3: res.append(self[i] ^ other[i])
+            else: res.append(chr(ord(self[i]) ^ ord(other[i])))
+            #print("res[%s] = %s" % (i, res[i]))
+        return Bytes(res)            
+
+    def __add__(self, other):
+        return Bytes(bytes.__add__(self, other))
+    
+    @classmethod
+    def fill(self, prefix, length):
+        '''Provides an easy way to create a byte array of a specified length and content'''
+        bits = b''
+        for i in range(0, int(length)):
+            bits += prefix
+        return Bytes(bits)
+        
+
+if py3:
+   def getBytes(arg1, arg2='utf-8'):
+       return Bytes(arg1, arg2)
+else:
+   def getBytes(arg1, arg2=None):
+       return bytes(arg1)
+# TODO: add left and right bit shifting