def deserialize(self, o):
assert type(o) == dict, 'Wrong file format.'
if 'param' in o:
self.group = PairingGroup(o['param'])
assert 'rest' in o, 'Wrong file format.'
d = deserializeObject(o['rest'], self.group)
else:
d = o
for key, value in d.items():
setattr(self, key, value)
return self
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))
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))
elif method == 'k':
(pk, sk) = bls.keygen()
try:
os.mkdir(namespace.directory)
except IOError:
pass
f1 = open(namespace.directory + namespace.public_key, 'wb')
f1.write(str(serializeDict(pk, bls.group)))
f1.close()
f2 = open(namespace.directory + namespace.secret_key, 'wb')
f2.write(str(serializeObject(sk, bls.group)))
f2.close()
elif method == 's':
try:
f1 = open(namespace.directory + namespace.secret_key, 'rb')
sk = deserializeObject(f1.read(), bls.group)
except IOError:
raise ApplicationError(
'Файла с закрытым ключом по указанному пути не существует')
f1.close()
if namespace.message == None and namespace.file == None:
raise StartingError(
'Не было указано сообщение или путь файла с сообщением')
elif namespace.message != None and namespace.file != None:
raise StartingError('Были указаны 2 вида сообщений')
elif namespace.message != None:
message = namespace.message
elif namespace.file != None:
try:
f2 = open(namespace.file, 'rb')
message = f2.read()
def deserialize(bytes, group):
serializedDict = pickle.loads(bytes)
serializedDictWithBase64 = reEncodeBase64Dict(serializedDict)
return deserializeObject(serializedDictWithBase64, group)