Exemple #1
0
def test2():
    client = UdpEndPoint()
    p = UdpEndPoint()
    group_object = PairingGroup('SS512')
    key_client = group_object.random(GT)
    key_p = group_object.random(GT)
    nonce = OpenSSLRand().getRandomBits(128)
    server_crypter_a = SymmetricCryptoAbstraction(extractor(key_client))
    server_crypter_b = SymmetricCryptoAbstraction(extractor(key_p))
    c_package_a = test1(client, p, nonce,
                        objectToBytes(key_client, group_object),
                        objectToBytes(key_p, group_object))
    print('===========================================================')
    print(c_package_a)
    key_package_a = server_crypter_a.decrypt(c_package_a)
    key_package_a = bytesToObject(key_package_a, group_object)
    key_package_b = server_crypter_b.decrypt(key_package_a[3])
    key_package_b = bytesToObject(key_package_b, group_object)
    print('===========================================================')
    i = 1
    for thing in key_package_a:
        print(str(i) + '.', thing)
        i += 1
    print('===========================================================')
    j = 1
    for thing in key_package_b:
        print(str(j) + '.', thing)
        j += 1
    print('===========================================================')
Exemple #2
0
def decrypt(key, cipher):
    a = SymmetricCryptoAbstraction(extractor(key))

    results = 0.0
    for i in range(0, number):
        start = time.clock()
        a.decrypt(content)
        end = time.clock()
        results += end - start
    mean = results / number
    logging.info("AES decrypt: " + str(mean))

    content = a.decrypt(cipher)
    return content
Exemple #3
0
def main():
    groupObj = PairingGroup('SS512')
    dabe = Dabe(groupObj)
    TP = dabe.get_Trapdoor_json("TRAPDOOR.json")
    par_filelist = get_files("./PARTIAL_CIPHERTEXT")
    if len(par_filelist) == 0:
        return
    des = "./PLAINTEXT/"
    if os.path.exists(des):
        shutil.rmtree(des)
    os.mkdir(des)
    for i in par_filelist:
        Par_CT = dabe.get_Par_CT_json(i)
        orig_m = dabe.full_decrypt(TP, Par_CT)
        #print("\nSymmetric key is")
        #print(orig_m)
        symcrypt = SymmetricCryptoAbstraction(extractor(orig_m))
        filename = "./MATCHED_FILE/SYMMETRIC_CIPHERTEXT_" + (
            i.split('_'))[3].split('.')[0] + ".ct"
        with open(filename, 'r') as f:
            cm = f.read()
        pm = symcrypt.decrypt(cm)
        #print(str(pm, encoding = 'utf-8'))
        filename = "./PLAINTEXT/SYMMETRIC_PLAINTEXT_" + (
            i.split('_'))[3].split('.')[0] + ".pp"
        with open(filename, 'w') as file_object:
            file_object.write(str(pm, encoding='utf-8'))
Exemple #4
0
def read(user, record):
    """
    Function to read some public health record, from a given user. Returns
    all parts of the record.

    :param user:      User public key that wants to read the health record
    :param record:    Public health record to be read
    """

    # Get the record from the file system and load the key
    data = data_helper.load(user, record)
    user_key = load_user_key(user)

    # Decrypt the symmetric key using the TIPRE key
    sym_crypto_key = pre.decrypt(get_params(), user_key, data[SYMKEY()])

    # Setup symmetric crypto
    sym_crypto = SymmetricCryptoAbstraction(extract_key(sym_crypto_key))

    # Attempt to decrypt all columns and return
    decrypted_record = {
        k: sym_crypto.decrypt(v)
        for k, v in data.items() if k != SYMKEY()
    }
    return decrypted_record
Exemple #5
0
 def MsgTestAESCBCSeperate(self, msg):
     groupObj = PairingGroup('SS512')
     ran = groupObj.random(GT)
     a = SymmetricCryptoAbstraction(sha1(ran))
     ct = a.encrypt(msg)
     b = SymmetricCryptoAbstraction(sha1(ran))
     dmsg = b.decrypt(ct)
     assert msg == dmsg, 'o: =>%s\nm: =>%s' % (msg, dmsg)
Exemple #6
0
 def decrypt_text(self, ct, secret):
     try:
         k = extractor(secret)
         symcrypt = SymmetricCryptoAbstraction(k)
         text = symcrypt.decrypt(ct)
         return text
     except Exception as e:
         print("Unexpected error:", str(e))
Exemple #7
0
 def MsgTestAESCBCSeperate(self,msg):
     groupObj = PairingGroup('SS512')
     ran = groupObj.random(GT)
     a =  SymmetricCryptoAbstraction(sha1(ran))
     ct = a.encrypt(msg)        
     b =  SymmetricCryptoAbstraction(sha1(ran))
     dmsg = b.decrypt(ct);
     assert msg == dmsg , 'o: =>%s\nm: =>%s' % (msg, dmsg)
Exemple #8
0
def ible(pre, ID, msg, k, master_key, params, log_file):

    if type(msg) != bytes: raise "Message type error: msg should be bytes."

    # switch for display
    #debug = True
    debug = False

    if debug:
        print("\nThe original message is: \n", msg)

    # Generate the Sym Cipher initilized by k
    symCipher = SymmetricCryptoAbstraction(k)

    # Symmetric Encrypt: AES(CTR) default
    t1 = time.time()
    ct = symCipher.encrypt(msg)
    t2 = time.time()
    t_aes = (t2 - t1) * 1000
    log = '{0:.4f}'.format(t_aes) + "\t"

    # Generate private keys for ID
    sk1 = pre.keyGen(master_key, ID)

    # Encrypt 'Sym k' using ID
    t1 = time.time()
    ck = pre.encrypt_jet(params, ID, k)
    t2 = time.time()
    t_ibe = (t2 - t1) * 1000
    log += '{0:.4f}'.format(t_ibe) + "\t"

    # decryption using sk1
    t1 = time.time()
    dk = pre.decrypt_jet(params, sk1, ck)
    t2 = time.time()
    t_ibd = (t2 - t1) * 1000
    log += '{0:.4f}'.format(t_ibd) + "\t"

    if debug:
        print("\nThe decrypted key is:\n", dk)

    # Transmit dk and ct to the receipt
    # ........

    # Sym decrypt using the IBD output
    decipher = SymmetricCryptoAbstraction(dk)

    t1 = time.time()
    dmsg = decipher.decrypt(ct)
    t2 = time.time()
    t_aes2 = (t2 - t1) * 1000
    log += '{0:.4f}'.format(t_aes2) + "\n"

    if debug:
        print("\nThe decrypted message is:\n", dmsg)
    assert dmsg == msg, 'o: =>%s\nm: =>%s' % (msg, dmsg)
    # output log
    log_file.write(log)
Exemple #9
0
    def decrypt(self, C, D):
        policy = util.createPolicy(D['policy'])
        attrs = util.prune(policy, C['attributes'])
        if attrs == False:
            return False
        coeff = util.getCoefficients(policy)

        Z = {}
        prodT = 1
        for i in range(len(attrs)):
            x = attrs[i].getAttribute()
            y = attrs[i].getAttributeAndIndex()
            Z[y] = C['Ci'][x]**D['Du'][x]
            prodT *= Z[y]**coeff[y]

        symcrypt = SymmetricCryptoAbstraction(extractor(prodT))

        return symcrypt.decrypt(C['C'])
Exemple #10
0
# print pk+"\n"
# print cipher+"\n"

mk = bytesToObject(mk, groupObj)
pk = bytesToObject(pk, groupObj)
cipher = bytesToObject(cipher, groupObj)

sk = cpabe.keygen(pk, mk, asl)

print sk

try:
    plaintext = cpabe.decrypt(pk, sk, cipher)
except:
    print "Error"

if plaintext != False:
    a = SymmetricCryptoAbstraction(sha1(plaintext))

    with open(fileUrl, "rb") as f:
        cloudfile = f.read()
    file = a.decrypt(cloudfile)

    with open(fileUrl, "wb") as re:
        re.write(file)
else:
    print "Dcrypto Fail!"

del groupObj

#os.remove(configUrl)
Exemple #11
0
 def decrypt(self, C, prodT,h):
     symcrypt = SymmetricCryptoAbstraction(hashPair(prodT*h))    
     return symcrypt.decrypt(C['C'])
Exemple #12
0
from charm.toolbox.pairinggroup import PairingGroup, GT
from charm.core.math.pairing import hashPair as sha1
from charm.schemes.abenc.abenc_waters09 import CPabe09
from charm.toolbox.symcrypto import SymmetricCryptoAbstraction, AuthenticatedCryptoAbstraction, MessageAuthenticator

asl = ['ONE', 'TWO']
groupObj = PairingGroup('SS512')
cpabe = CPabe09(groupObj)

with open('/Users/cirnotxm/down/info', 'rb') as f:
    info = f.read()

cpkey = cpabe.keygen(pk, msk, asl)

with open('/Users/cirnotxm/down/cipk', 'r') as f2:
    ciphertext = f2.read()

ciphertext = eval(ciphertext)

print ciphertext

prig_msg = cpabe.decrypt(pk, cpkey, ciphertext)

a2 = SymmetricCryptoAbstraction(sha1(orig_symKey))

plaintext = a2.decrypt(info)

print plaintext
Exemple #13
0
def dec(k1, k2, ct):
    a1 = SymmetricCryptoAbstraction(k1.to_bytes(16, byteorder='big'))
    a2 = SymmetricCryptoAbstraction(k2.to_bytes(16, byteorder='big'))
    m0 = a2.decrypt(ct)
    m1 = a1.decrypt(m0)
    return m1
Exemple #14
0
from charm.toolbox.pairinggroup import PairingGroup, ZR, G1, G2, GT, pair, extract_key
from charm.toolbox.symcrypto import AuthenticatedCryptoAbstraction, SymmetricCryptoAbstraction
from charm.core.math.pairing import hashPair as extractor

group = PairingGroup("SS512")

msg = b"This is a secret message that is larger than the group elements and has to be encrypted symmetrically"
print("original msg\n", msg)

r = group.random(G1)
print("random num\n", r)

# key = extractor(r)
key = extract_key(r)
print("symmetric key\n", key)

symcrypt = SymmetricCryptoAbstraction(
    key)  # or SymmetricCryptoAbstraction without authentication
# by default algo is AES in CBC mode

# encryption
ciphertext = symcrypt.encrypt(msg)
print("ciphertext\n", ciphertext)

# decryption
recoveredMsg = symcrypt.decrypt(ciphertext)
print("recovered msg\n", recoveredMsg)

assert msg == recoveredMsg
Exemple #15
0
from charm.core.math.pairing import hashPair as sha1
from charm.schemes.abenc.abenc_waters09 import CPabe09
from charm.toolbox.symcrypto import SymmetricCryptoAbstraction,AuthenticatedCryptoAbstraction, MessageAuthenticator

asl= ['ONE','TWO']
groupObj = PairingGroup('SS512')
cpabe = CPabe09(groupObj)


with open('/Users/cirnotxm/down/info','rb') as f:
    info = f.read()


cpkey = cpabe.keygen(pk,msk,asl)

with open('/Users/cirnotxm/down/cipk','r') as f2:
    ciphertext = f2.read()


ciphertext = eval(ciphertext)

print ciphertext

prig_msg = cpabe.decrypt(pk,cpkey,ciphertext)

a2 =  SymmetricCryptoAbstraction(sha1(orig_symKey))

plaintext = a2.decrypt(info)

print plaintext
Exemple #16
0
def hibre(pre, ID1, ID2, msg, k, master_key, params, log_file):
    if type(msg) != bytes: raise "Message type error: msg should be bytes."
    # switch for display
    #debug = True
    debug = False

    if debug:
        print("\nThe original message is: \n", msg)

    # Generate IBE private keys for IDs
    sk1 = pre.keyGen(master_key, ID1)

    sk2 = pre.keyGen(master_key, ID2)

    # Generate the Sym Cipher initilized by k
    symCipher = SymmetricCryptoAbstraction(k)

    # Symmetric Encrypt the message: AES(CTR) default
    t1 = time.time()
    ct = symCipher.encrypt(msg)
    t2 = time.time()
    t_aes = (t2 - t1) * 1000
    log = '{0:.4f}'.format(t_aes) + "\t"

    # Generate Re-Key (1-->2), using sk1 and ID2
    t1 = time.time()
    rk = pre.rkGen(params, sk1, ID2)
    t2 = time.time()
    t_grk = (t2 - t1) * 1000

    log += '{0:.4f}'.format(t_grk) + "\t"

    # IBE the sym key using ID1: IBE1
    t1 = time.time()
    ck = pre.encrypt_jet(params, ID1, k)
    t2 = time.time()
    t_kibe = (t2 - t1) * 1000

    log += '{0:.4f}'.format(t_kibe) + "\t"

    # Re-encrypt using Re-Key
    t1 = time.time()
    ck2 = pre.reEncrypt_jet(params, rk, ck)
    t2 = time.time()
    t_kre = (t2 - t1) * 1000
    log += '{0:.4f}'.format(t_kre) + "\t"

    # IBD using sk2 to get sym key
    t1 = time.time()
    dk = pre.decrypt_jet(params, sk2, ck2)
    t2 = time.time()
    t_kibd = (t2 - t1) * 1000
    log += '{0:.4f}'.format(t_kibd) + "\t"

    # Sym decrypt using the IBD output
    # Generate sym cipher using the output key
    decipher = SymmetricCryptoAbstraction(dk)

    t1 = time.time()
    dmsg = decipher.decrypt(ct)
    t2 = time.time()
    t_aes2 = (t2 - t1) * 1000
    log += '{0:.4f}'.format(t_aes2) + "\n"

    if debug:
        print("\nThe decrypted message is:\n", dmsg)
    assert dmsg == msg, 'o: =>%s\nm: =>%s' % (msg, dmsg)

    log_file.write(log)
Exemple #17
0
 def MsgtestAESCBC(self,msg):
     groupObj = PairingGroup('SS512')
     a =  SymmetricCryptoAbstraction(sha1(groupObj.random(GT)))
     ct = a.encrypt(msg)
     dmsg = a.decrypt(ct);
     assert msg == dmsg , 'o: =>%s\nm: =>%s' % (msg, dmsg)
Exemple #18
0
def decrypt(cryptogram, key1, key2):
    k1 = SymmetricCryptoAbstraction(key1)
    k2 = SymmetricCryptoAbstraction(key2)
    m0 = k2.decrypt(cryptogram)
    m1 = k1.decrypt(m0)
    return m1
Exemple #19
0
 def MsgtestAESCBC(self, msg):
     groupObj = PairingGroup('SS512')
     a = SymmetricCryptoAbstraction(sha1(groupObj.random(GT)))
     ct = a.encrypt(msg)
     dmsg = a.decrypt(ct)
     assert msg == dmsg, 'o: =>%s\nm: =>%s' % (msg, dmsg)
Exemple #20
0
                                       aes_key_ct_recovered)
    print("Pxy Decrypt...")
    print("Intermediate decryption =>", intmed_value)

    # USER DECRYPTS THE AES KEY BY USING INTMD VALUE
    recovered_aes_key = cpabe.user_decrypt(cloud_pk, sk_u, intmed_value)
    print("\nUser Decrypt...")
    print("Recovered message =>", recovered_aes_key)

    print("\n============ Decrypted Text =============\n")

    # RECOVER THE AES SYMM ENCRYPTION CONFIGURATION
    rec_secret = extractor(recovered_aes_key)
    rec_symcrypt = SymmetricCryptoAbstraction(rec_secret)

    rec_file_pt = rec_symcrypt.decrypt(read_file_ct)

    print_byte_array(rec_file_pt[:15])
    print("...")

    print("\nLENGTH OF DEC FILE", len(rec_file_pt))

    # OUTPUT THE RECOVERED FILE PLAINTEXT
    outputFileObj = open(outputFilename, 'wb')
    outputFileObj.write(bytes(rec_file_pt))
    outputFileObj.close()

    # DISPLAY THE FINAL OUTCOME
    if rec_file_pt == file_pt:
        print("Demonstration Succeeded!")
    else:
Exemple #21
0
def decrypt(k1, k2, ctx):
    a1 = SymmetricCryptoAbstraction(h(k1))
    a2 = SymmetricCryptoAbstraction(h(k2))
    expansion_ratio = a1.decrypt((a2.decrypt(ctx)).decode("utf-8"))
    return expansion_ratio
Exemple #22
0
    bytest_text = symcrypto.encrypt(msg)

    (master_secret_key, params) = pre.setup()

    # Run by trusted party, someone needs to handle the master secret key
    id1_secret_key = pre.keyGen(master_secret_key, ID1)
    id2_secret_key = pre.keyGen(master_secret_key, ID2)

    # Run by delegator (id_name_1), encrypt the sym key
    ciphertext = pre.encrypt(params, ID1, symcrypto_key, id1_secret_key, type_attribute)

    # Directly decrypt ciphertext by the same party
    plain = pre.decrypt(params, id1_secret_key, ciphertext)
    print('Symmetric key directly decrypted by party 1: {}\n'.format(plain))

    # # Run by delegator (id_name_1) create reencryption key for ID2, used by the proxy
    re_encryption_key = pre.rkGen(params, id1_secret_key, ID2, type_attribute)

    # Run by the proxy, uses the re encryption key generated by ID1
    ciphertext2 = pre.reEncrypt(params, re_encryption_key, ciphertext)

    # Run by the delegatee (id_name_2), retrieve the secrey key
    symcrypto_key_decrypted = pre.decrypt(params, id2_secret_key, ciphertext2)
    print('Symmetric key decrypted by party 2: {}'.format(symcrypto_key_decrypted))

    # Use the secrey key to decrypt a msg
    symcrypto = SymmetricCryptoAbstraction(extract_key(symcrypto_key_decrypted))
    decrypted_ct = symcrypto.decrypt(bytest_text)

    print('Decrypted: {}'.format(decrypted_ct))
Exemple #23
0
    def onInitData(self, interest, data):
        """
        Data:
            Content: 
                master_public_key to PKG
                ibeKey = ibe(randomKey)
                cipher = encrypt(PrivateKey, randomKey)

        Decrypt the symmetric key with the TemporaryMasterPublicKey and the device ID.
        Use the symmetric key to decrypt the PrivateKey.

        Device is now added to the PKG        
        
        :param Interest interest:
        :param Data data:
        """
        message = messageBuf_pb2.Message()
        message.ParseFromString(data.getContent().toRawStr())

        # TODO: Compare session
        if not self.initSession == message.nonce:
            logging.warning("Nonce is not equal!")

        # SignatureMasterPublicKey
        signatureMasterPublicKeyDict = ast.literal_eval(
            message.identityBasedSignatureMasterPublicKey)
        self.signature_master_public_key = deserializeObject(
            signatureMasterPublicKeyDict, self.ibs_scheme.group)
        # Verify signature
        self.ibs_scheme.verifyData(self.signature_master_public_key, data,
                                   self.onVerifiedData,
                                   self.onVerifyDataFailed)

        if (message.type == messageBuf_pb2.Message.INIT):
            if (message.encAlgorithm == messageBuf_pb2.Message.AES):
                # Check if IBS algorithm is the same
                if not (self.ibs_scheme.algorithm == message.ibsAlgorithm):
                    logging.error("IBS algorithm doesnt match! Receiver: " +
                                  self.ibs_scheme.algorithm + ", Sender: " +
                                  message.ibsAlgorithm)

                # Check if IBE algorithm is the same
                if not (self.ibe_scheme.algorithm == message.ibeAlgorithm):
                    logging.error("IBE algorithm doesnt match! Receiver: " +
                                  self.ibe_scheme.algorithm + ", Sender: " +
                                  message.ibeAlgorithm)

                #Decrypt encryptedMessage
                # PrivateKeys
                a = SymmetricCryptoAbstraction(self.presharedKey)
                privateKeyEncoded = a.decrypt(message.encryptedPK)
                signaturePrivateKeyEncoded = a.decrypt(message.encryptedSPK)
                self.private_key = bytesToObject(privateKeyEncoded,
                                                 self.ibe_scheme.group)
                self.signature_private_key = bytesToObject(
                    signaturePrivateKeyEncoded, self.ibs_scheme.group)

                # MasterPublicKey
                masterPublicKeyDict = ast.literal_eval(
                    message.identityBasedMasterPublicKey)
                self.master_public_key = deserializeObject(
                    masterPublicKeyDict, self.ibe_scheme.group)

                logging.info(
                    "Initialization success! PrivateKeys, MasterPublicKeys received."
                )
                self.initRequestEnd = time.clock()
                logging.info("Initialization time: " +
                             str(self.initRequestEnd - self.initRequestStart))
Exemple #24
0
def dec(k1, k2, ct):
    a1 = SymmetricCryptoAbstraction(k1)
    a2 = SymmetricCryptoAbstraction(k2)
    m0 = a2.decrypt(ct)
    m1 = a1.decrypt(m0)
    return m1
Exemple #25
0
    def onData(self, interest, data):
        """
        Data:
            Content: 
                master_public_key to PKG
                ibeKey = ibe(randomKey)
                cipher = encrypt(PrivateKey, randomKey)

        Decode the master_public_key and compare it to the device.master_public_key (if they match, they trust the same PKG)
        Decrypt the symmetric key, and decrypt the cipher

        Sensor Data reveiced! 

        :param Interest interest:
        :param Data data:
        """
        self.ibs_scheme.verifyData(self.signature_master_public_key, data,
                                   self.onVerifiedData,
                                   self.onVerifyDataFailed)

        message = messageBuf_pb2.Message()
        message.ParseFromString(data.getContent().toRawStr())

        # TODO: compare nonce
        session = message.nonce

        if (message.type == messageBuf_pb2.Message.SENSOR_DATA):
            if (message.encAlgorithm == messageBuf_pb2.Message.AES):

                # Check if IBS algorithm is the same
                if not (self.ibs_scheme.algorithm == message.ibsAlgorithm):
                    logging.error("IBS algorithm doesnt match! Receiver: " +
                                  self.ibs_scheme.algorithm + ", Sender: " +
                                  message.ibsAlgorithm)

                #Compare signature_master_public_key
                signatureMasterPublicKeyDict = ast.literal_eval(
                    message.identityBasedSignatureMasterPublicKey)
                messageSignatureMPK = deserializeObject(
                    signatureMasterPublicKeyDict, self.ibs_scheme.group)
                if not (self.signature_master_public_key
                        == messageSignatureMPK):
                    logging.error("SignatureMasterPulicKey does not match!")

                # Check if IBE algorithm is the same
                if not (self.ibe_scheme.algorithm == message.ibeAlgorithm):
                    logging.error("IBE algorithm doesnt match! Receiver: " +
                                  self.ibe_scheme.algorithm + ", Sender: " +
                                  message.ibeAlgorithm)

                #Compare master_public_key
                masterPublicKeyDict = ast.literal_eval(
                    message.identityBasedMasterPublicKey)
                messageMPK = deserializeObject(masterPublicKeyDict,
                                               self.ibe_scheme.group)
                if not (self.master_public_key == messageMPK):
                    logging.error("MasterPulicKey does not match!")

                #Decrypt identityBasedEncrypedKey
                identityBasedEncryptedKeyDict = ast.literal_eval(
                    message.identityBasedEncryptedKey)
                identityBasedEncryptedKey = deserializeObject(
                    identityBasedEncryptedKeyDict, self.ibe_scheme.group)
                key = self.ibe_scheme.decryptKey(self.master_public_key,
                                                 self.private_key,
                                                 identityBasedEncryptedKey)

                #Decrypt encryptedMessage
                a = SymmetricCryptoAbstraction(extractor(key))
                data = a.decrypt(message.encryptedMessage)

                # Use data from device to something ..
                logging.info("Data received: " + str(data))
                self.dataRequestEnd = time.clock()
                logging.info("Request and receive data time: " +
                             str(self.dataRequestEnd - self.dataRequestStart))
Exemple #26
0
def sym_decrypt(ciphertext, key):
    decrypter = SymmetricCryptoAbstraction(extractor(key))
    serial_pt = decrypter.decrypt(ciphertext)
    return bytesToObject(serial_pt, PairingGroup('SS512'))
Exemple #27
0
from charm.toolbox.symcrypto import SymmetricCryptoAbstraction, AuthenticatedCryptoAbstraction, MessageAuthenticator
from charm.toolbox.pairinggroup import PairingGroup, GT
from charm.core.math.pairing import hashPair as sha1

debug = 0

groupObj = PairingGroup('SS512')

try:
    f = open('/Users/cirnotxm/down/pk', 'rb')
    pk = f.read()

    a = SymmetricCryptoAbstraction(sha1(groupObj.deserialize(pk)))

    ffe = open('/Users/cirnotxm/down/jiami', 'rb')

    ct = ffe.read()

    de = a.decrypt(ct)

    fpk = open('/Users/cirnotxm/down/jiemi.dmg', 'wb')

    fpk.write(de)

finally:

    ffe.close()
    f.close()
    fpk.close()
Exemple #28
0
# print pk+"\n"
# print cipher+"\n"

mk = bytesToObject(mk,groupObj)
pk = bytesToObject(pk,groupObj)
cipher = bytesToObject(cipher,groupObj)

sk = cpabe.keygen(pk,mk,asl)

print sk

try:
    plaintext = cpabe.decrypt(pk,sk,cipher)
except:
    print "Error"

if plaintext!=False :
    a = SymmetricCryptoAbstraction(sha1(plaintext))

    with open(fileUrl,"rb") as f:
        cloudfile = f.read()
    file = a.decrypt(cloudfile)

    with open(fileUrl,"wb") as re:
        re.write(file)
else:
    print "Dcrypto Fail!"

del groupObj

#os.remove(configUrl)