예제 #1
0
 def processPendingContacts(torId):
     print("Process pending contact accept responses from:", torId)
     foundReq = False
     for resp in DbI.getPendingContactMessages(torId):
         name = resp.get("fromName", None)
         if not name:
             profile = DbI.getProfile(torId)
             name = profile["displayName"]
         print("Found pending contact accept request from: ", name)
         # Check signature using keyring
         _, signatureKey = CryptoClient.decryptAndCheckSignature(
             resp.get("encryptedMsg", None))
         if signatureKey:
             foundReq = True
             # Insert new message into inbox with message contents
             rowToStore = {
                 "messageType": "contactresponse",
                 "fromId": resp.get("fromId", None),
                 "fromName": name,
                 "accepted": True,
                 "messageBody": resp.get("messageBody", ""),
                 "timestamp": resp.get("timestamp", None),
                 "messageRead": True,
                 "messageReplied": True,
                 "recipients": DbI.getOwnTorid()
             }
             DbI.addToInbox(rowToStore)
     if foundReq:
         DbI.updateProfile(torId, {"status": "untrusted"})
         # Delete all pending contact responses from this torId
         DbI.deletePendingContactMessages(torId)
예제 #2
0
파일: message.py 프로젝트: bellyfat/Murmeli
    def construct(payload, isEncrypted=True):
        '''Factory constructor using a given payload and extracting the fields'''
        if not payload:
            return None
        signatureKey = None
        if isEncrypted:
            # Decrypt the payload with our key
            decrypted, signatureKey = CryptoClient.decryptAndCheckSignature(
                payload)
        else:
            decrypted = payload
        if decrypted:
            print("Asymmetric message, length of decrypted is", len(decrypted))
        else:
            print("Asymmetric message has no decrypted")
        # Separate fields of message into common ones and the type-specific payload
        msgType, subpayload, tstmp = AsymmetricMessage._stripFields(decrypted)
        print("Recovered timestamp='", tstmp, "' (", len(tstmp), ")")

        # Find a suitable subclass to call using the messageType
        msg = None
        if msgType == Message.TYPE_CONTACT_RESPONSE:
            msg = ContactResponseMessage.constructFrom(subpayload)
        elif msgType == Message.TYPE_STATUS_NOTIFY:
            msg = StatusNotifyMessage.constructFrom(subpayload)
        elif msgType == Message.TYPE_ASYM_MESSAGE:
            msg = RegularMessage.constructFrom(subpayload)
        elif msgType == Message.TYPE_INFO_REQUEST:
            msg = InfoRequestMessage.constructFrom(subpayload)
        elif msgType == Message.TYPE_INFO_RESPONSE:
            msg = InfoResponseMessage.constructFrom(subpayload)
        elif msgType == Message.TYPE_FRIEND_REFERRAL:
            msg = ContactReferralMessage.constructFrom(subpayload)
        elif msgType == Message.TYPE_FRIENDREFER_REQUEST:
            msg = ContactReferRequestMessage.constructFrom(subpayload)
        # Ask the message if it's ok to have no signature
        if isEncrypted and msg:
            if msg.acceptUnrecognisedSignature():
                # Save the encrypted contents so we can verify it later
                msg.encryptedContents = payload
            elif not signatureKey:
                msg = None
        if msg:
            try:
                msgTimestamp = tstmp.decode('utf-8')
            except:
                msgTimestamp = msg.makeCurrentTimestamp()
            msg.timestamp = Message.convertTimestampFromString(msgTimestamp)
            msg.signatureKeyId = signatureKey
            if signatureKey:
                print(
                    "Asymm setting senderId because I've got a signatureKey: '%s'"
                    % signatureKey)
                signatureId = DbI.findUserIdFromKeyId(signatureKey)
                if signatureId:
                    msg.senderId = signatureId
        return msg
예제 #3
0
	def construct(payload, isEncrypted=True):
		'''Factory constructor using a given payload and extracting the fields'''
		if not payload:
			return None
		signatureKey = None
		if isEncrypted:
			# Decrypt the payload with our key
			decrypted, signatureKey = CryptoClient.decryptAndCheckSignature(payload)
		else:
			decrypted = payload
		if decrypted:
			print("Asymmetric message, length of decrypted is", len(decrypted))
		else:
			print("Asymmetric message has no decrypted")
		# Separate fields of message into common ones and the type-specific payload
		msgType, subpayload, tstmp = AsymmetricMessage._stripFields(decrypted)
		print("Recovered timestamp='", tstmp, "' (", len(tstmp), ")")

		# Find a suitable subclass to call using the messageType
		msg = None
		if msgType == Message.TYPE_CONTACT_RESPONSE:
			msg = ContactResponseMessage.constructFrom(subpayload)
		elif msgType == Message.TYPE_STATUS_NOTIFY:
			msg = StatusNotifyMessage.constructFrom(subpayload)
		elif msgType == Message.TYPE_ASYM_MESSAGE:
			msg = RegularMessage.constructFrom(subpayload)
		elif msgType == Message.TYPE_INFO_REQUEST:
			msg = InfoRequestMessage.constructFrom(subpayload)
		elif msgType == Message.TYPE_INFO_RESPONSE:
			msg = InfoResponseMessage.constructFrom(subpayload)
		elif msgType == Message.TYPE_FRIEND_REFERRAL:
			msg = ContactReferralMessage.constructFrom(subpayload)
		# Ask the message if it's ok to have no signature
		if isEncrypted and msg:
			if msg.acceptUnrecognisedSignature():
				# Save the encrypted contents so we can verify it later
				msg.encryptedContents = payload
			elif not signatureKey:
				msg = None
		if msg:
			try:
				msgTimestamp = tstmp.decode('utf-8')
			except:
				msgTimestamp = msg.makeCurrentTimestamp()
			msg.timestamp = Message.convertTimestampFromString(msgTimestamp)
			msg.signatureKeyId = signatureKey
			if signatureKey:
				print("Asymm setting senderId because I've got a signatureKey: '%s'" % signatureKey)
				signatureId = DbClient.findUserIdFromKeyId(signatureKey)
				if signatureId:
					msg.senderId = signatureId
		return msg
예제 #4
0
	def testEncDecryption(self):
		self._setupKeyring(["key1_private", "key1_public"])
		MESSAGE = "This is the unencrypted source text we're going to use".encode("utf-8")
		RECPTKEYID = self.KEYID_1
		# encrypt for ourselves
		ans = CryptoClient.encryptAndSign(MESSAGE, RECPTKEYID, RECPTKEYID)
		self.assertIsNotNone(ans, "Encrypted result shouldn't be none")
		backAgain, sigok = CryptoClient.decryptAndCheckSignature(ans)
		self.assertIsNotNone(backAgain, "Decrypted result shouldn't be none")
		self.assertTrue(sigok, "Signature check should be ok")
		self.assertNotEqual(len(backAgain), 0, "Decrypted result shouldn't have zero length")
		self.assertNotEqual(ans, MESSAGE, "Encrypted result shouldn't be the same as the input")
		self.assertEqual(backAgain, MESSAGE, "Decrypted result should be the same as the input")
예제 #5
0
	def testDecryptValid(self):
		self._setupKeyring(["key1_private", "key2_public"])
		ENCRYPTED_MESSAGE = self.MESSAGE_FROM_2_FOR_1
		backAgain, sigok = CryptoClient.decryptAndCheckSignature(ENCRYPTED_MESSAGE)
		self.assertIsNotNone(backAgain, "Decryption of valid data shouldn't give none")
		self.assertTrue(sigok, "Signature check should be ok")
예제 #6
0
	def testDecryptUnrecognisedSig(self):
		self._setupKeyring(["key1_private"])
		ENCRYPTED_MESSAGE = self.MESSAGE_FROM_2_FOR_1
		backAgain, sigok = CryptoClient.decryptAndCheckSignature(ENCRYPTED_MESSAGE)
		self.assertIsNotNone(backAgain, "Decryption of encrypted text with unrecognised signature should still give a result")
		self.assertFalse(sigok, "Signature check should give false")
예제 #7
0
	def testDecryptNotForMe(self):
		self._setupKeyring(["key1_public", "key2_private"])
		ENCRYPTED_MESSAGE = self.MESSAGE_FROM_2_FOR_1
		backAgain, sigok = CryptoClient.decryptAndCheckSignature(ENCRYPTED_MESSAGE)
		self.assertIsNone(backAgain, "Failed decryption should give none")
		self.assertFalse(sigok, "Signature check should give false")
예제 #8
0
	def testDecryptBlank(self):
		self._setupKeyring(["key1_private", "key1_public"])
		backAgain, sigok = CryptoClient.decryptAndCheckSignature("")
		self.assertIsNone(backAgain, "Decryption of empty string should give none")
		self.assertFalse(sigok, "Signature check should give false")
예제 #9
0
	def testDecryptPlaintext(self):
		self._setupKeyring(["key1_private", "key1_public"])
		MESSAGE = "This is the unencrypted source text we're going to use".encode("utf-8")
		backAgain, sigok = CryptoClient.decryptAndCheckSignature(MESSAGE)
		self.assertIsNone(backAgain, "Decryption of plaintext should give none")
		self.assertFalse(sigok, "Signature check should give false")