def toProtocolTreeNode(self):
node = super(MediaMessageProtocolEntity, self).toProtocolTreeNode()
mediaNode = ProtocolTreeNode("media", {"type": self.mediaType}, None, None)
node.addChild(mediaNode)
if self.preview:
mediaNode.setData(self.preview)
return node
def toProtocolTreeNode(self):
node = super(ListGroupsResultIqProtocolEntity, self).toProtocolTreeNode()
groupsNodes = []
for group in self.groupsList:
groupNode = ProtocolTreeNode("group", {
"id": group.getId(),
"creator": group.getCreator(),
"subject": group.getSubject(),
"s_o": group.getSubjectOwner(),
"s_t": str(group.getSubjectTime()),
"creation": str(group.getCreationTime())
},
)
participants = []
for jid, _type in group.getParticipants().items():
pnode = ProtocolTreeNode("participant", {"jid": jid})
if _type:
pnode["type"] = _type
participants.append(pnode)
groupNode.addChildren(participants)
groupsNodes.append(groupNode)
node.addChild(ProtocolTreeNode("groups", children = groupsNodes))
return node
def toProtocolTreeNode(self):
node = super(ErrorIqProtocolEntity, self).toProtocolTreeNode()
errorNode = ProtocolTreeNode("error", {"text": self.text, "code": self.code})
if self.backoff:
errorNode.setAttribute("backoff", str(self.backoff))
node.addChild(errorNode)
return node
def toProtocolTreeNode(self):
node = super(CryptoIqProtocolEntity, self).toProtocolTreeNode()
cryptoNode = ProtocolTreeNode("crypto", {"action": "create"})
googleNode = ProtocolTreeNode("google", data = "fe5cf90c511fb899781bbed754577098e460d048312c8b36c11c91ca4b49ca34".decode('hex'))
cryptoNode.addChild(googleNode)
node.addChild(cryptoNode)
return node
def toProtocolTreeNode(self):
node = super(PrivacyListIqProtocolEntity, self).toProtocolTreeNode()
queryNode = ProtocolTreeNode("query")
listNode = ProtocolTreeNode("list", {"name": self.listName})
queryNode.addChild(listNode)
node.addChild(queryNode)
return node
def setUp(self):
super(BroadcastTextMessageTest, self).setUp()
self.ProtocolEntity = BroadcastTextMessage
broadcastNode = ProtocolTreeNode("broadcast")
jids = ["jid1", "jid2"]
toNodes = [ProtocolTreeNode("to", {"jid" : jid}) for jid in jids]
broadcastNode.addChildren(toNodes)
self.node.addChild(broadcastNode)
def toProtocolTreeNode(self):
node = super(SetPrivacyIqProtocolEntity, self).toProtocolTreeNode()
queryNode = ProtocolTreeNode(self.__class__.XMLNS)
for name in self.names:
listNode = ProtocolTreeNode("category", {"name": name, "value": self.value})
queryNode.addChild(listNode)
node.addChild(queryNode)
return node
def toProtocolTreeNode(self):
node = super(GetKeysIqProtocolEntity, self).toProtocolTreeNode()
keyNode = ProtocolTreeNode("key")
for jid in self.getJids():
userNode = ProtocolTreeNode("user", { "jid": jid })
keyNode.addChild(userNode)
node.addChild(keyNode)
return node
def toProtocolTreeNode(self):
node = super(CreateGroupsIqProtocolEntity, self).toProtocolTreeNode()
cnode = ProtocolTreeNode("create", {"subject": self.subject})
participantNodes = [
ProtocolTreeNode("participant", {"jid": participant}) for participant in self.participantList
]
cnode.addChildren(participantNodes)
node.addChild(cnode)
return node
def toProtocolTreeNode(self):
node = super(AddParticipantsIqProtocolEntity, self).toProtocolTreeNode()
node_add_label = ProtocolTreeNode("add")
node_participant_label = ProtocolTreeNode("participant", {"jid": self.jid})
node_add_label.addChild(node_participant_label)
node.addChild(node_add_label)
return node
def toProtocolTreeNode(self):
node = super(GetKeysIqProtocolEntity, self).toProtocolTreeNode()
keyNode = ProtocolTreeNode("key")
for jid in self.jids:
attrs = { "jid": jid }
if self.reason is not None:
attrs["reason"] = self.reason
userNode = ProtocolTreeNode("user", attrs)
keyNode.addChild(userNode)
node.addChild(keyNode)
return node
def toProtocolTreeNode(self):
node = super(AddGroupsNotificationProtocolEntity, self).toProtocolTreeNode()
addNode = ProtocolTreeNode("add")
participants = []
for jid in self.getParticipants():
pnode = ProtocolTreeNode("participant", {"jid": jid})
participants.append(pnode)
addNode.addChildren(participants)
node.addChild(addNode)
return node
def toProtocolTreeNode(self):
node = super(RemoveGroupsNotificationProtocolEntity, self).toProtocolTreeNode()
removeNode = ProtocolTreeNode("remove", {"subject": self.subject})
participants = []
for jid in self.getParticipants():
pnode = ProtocolTreeNode("participant", {"jid": jid})
participants.append(pnode)
removeNode.addChildren(participants)
node.addChild(removeNode)
return node
def toProtocolTreeNode(self):
node = super(EncryptedMessageProtocolEntity, self).toProtocolTreeNode()
participantsNode = ProtocolTreeNode("participants")
for enc in self.encEntities:
encNode = enc.toProtocolTreeNode()
if encNode.tag == "to":
participantsNode.addChild(encNode)
else:
node.addChild(encNode)
if len(participantsNode.getAllChildren()):
node.addChild(participantsNode)
return node
def test_encode(self):
node = ProtocolTreeNode("message", {
"form": "abc",
"to": "xyz"
}, [ProtocolTreeNode("media", {"width": "123"}, data="123456")])
result = self.encoder.protocolTreeNodeToBytes(node)
self.assertTrue(result in ([
248, 6, 89, 252, 4, 102, 111, 114, 109, 252, 3, 97, 98, 99, 165,
252, 3, 120, 121, 122, 248, 1, 248, 4, 87, 236, 99, 252, 3, 49, 50,
51, 252, 6, 49, 50, 51, 52, 53, 54
], [
248, 6, 89, 165, 252, 3, 120, 121, 122, 252, 4, 102, 111, 114, 109,
252, 3, 97, 98, 99, 248, 1, 248, 4, 87, 236, 99, 252, 3, 49, 50,
51, 252, 6, 49, 50, 51, 52, 53, 54
]))
def toProtocolTreeNode(self):
node = super(ContactsSyncNotificationProtocolEntity,
self).toProtocolTreeNode()
syncNode = ProtocolTreeNode("sync", {"after": str(self.after)}, None,
None)
node.addChild(syncNode)
return node
def handleAudioMessage(self, originalEncNode, audioMessage):
messageNode = copy.deepcopy(originalEncNode)
messageNode["type"] = "media"
mediaNode = ProtocolTreeNode(
"media", {
"type":
"audio",
"filehash":
audioMessage.file_sha256,
"size":
str(audioMessage.file_length),
"url":
audioMessage.url,
"mimetype":
audioMessage.mime_type.split(';')[0],
"encoding":
audioMessage.mime_type.split(';')[1].strip()
if len(audioMessage.mime_type.split(';')) > 1 else "",
"duration":
str(audioMessage.duration),
"seconds":
str(audioMessage.duration),
"encoding":
"raw",
"file":
"enc",
"ip":
"0",
"mediakey":
audioMessage.media_key
})
messageNode.addChild(mediaNode)
self.toUpper(messageNode)
def toProtocolTreeNode(self):
node = super(AddContactNotificationProtocolEntity,
self).toProtocolTreeNode()
removeNode = ProtocolTreeNode("add", {"jid": self.contactJid}, None,
None)
node.addChild(removeNode)
return node
def setUp(self):
self.ProtocolEntity = AuthProtocolEntity
self.node = ProtocolTreeNode("auth", {
"user": "******",
"mechanism": "WAUTH-2",
"passive": "false"
})
def toProtocolTreeNode(self):
node = super(MediaMessageProtocolEntity, self).toProtocolTreeNode()
mediaNode = ProtocolTreeNode("media", {"type": self.mediaType}, None, None)
node.addChild(mediaNode)
if self.preview:
node.setData(self.preview)
return node
def toProtocolTreeNode(self):
children = []
attribs = {
"t": str(self.timestamp),
"offline": "1" if self.offline else "0",
"id": self._id,
}
if self._from is not None:
attribs["from"] = self._from
if self._to is not None:
attribs["to"] = self._to
if self.retry is not None:
attribs["retry"] = self.retry
if self.e is not None:
attribs["e"] = self.e
if self.notify is not None:
attribs["notify"] = self.notify
if self._type in [
"offer", "transport", "relaylatency", "reject", "terminate"
]:
child = ProtocolTreeNode(self._type, {"call-id": self.callId})
children.append(child)
return self._createProtocolTreeNode(attribs,
children=children,
data=None)
def setUp(self):
self.ProtocolEntity = IqProtocolEntity
self.node = ProtocolTreeNode("iq", {
"id": "test_id",
"type": "get",
"xmlns": "iq_xmlns"
}, None, None)
def toProtocolTreeNode(self):
node = super(ResultRequestUploadIqProtocolEntity,
self).toProtocolTreeNode()
if not self.isDuplicate():
mediaNode = ProtocolTreeNode("encr_media", {"url": self.url})
if self.ip:
mediaNode["ip"] = self.ip
if self.resumeOffset:
mediaNode["resume"] = str(self.resumeOffset)
else:
mediaNode = ProtocolTreeNode("duplicate", {"url": self.url})
node.addChild(mediaNode)
return node
def toProtocolTreeNode(self):
node = super(ListGroupsResultIqProtocolEntity,
self).toProtocolTreeNode()
groupsNodes = [
ProtocolTreeNode(
"group", {
"id": group.getId(),
"creator": group.getCreator(),
"subject": group.getSubject(),
"s_o": group.getSubjectOwner(),
"s_t": str(group.getSubjectTime()),
"creation": str(group.getCreationTime())
}) for group in self.groupsList
]
node.addChild(ProtocolTreeNode("groups", {}, groupsNodes))
return node
def toProtocolTreeNode(self):
node = super(CryptoIqProtocolEntity, self).toProtocolTreeNode()
cryptoNode = ProtocolTreeNode("crypto", {"action": "create"})
# googleNode = ProtocolTreeNode("google", data = "fe5cf90c511fb899781bbed754577098e460d048312c8b36c11c91ca4b49ca34".decode('hex'))
# cryptoNode.addChild(googleNode)
node.addChild(cryptoNode)
return node
def setUp(self):
super(SyncIqProtocolEntityTest, self).setUp()
self.ProtocolEntity = SyncIqProtocolEntity
syncNodeAttrs = {"sid": "SID", "index": "0", "last": "true"}
syncNode = ProtocolTreeNode("sync", syncNodeAttrs)
self.node.addChild(syncNode)
def toProtocolTreeNode(self):
node = super(EncryptedMessageProtocolEntity, self).toProtocolTreeNode()
encNode = ProtocolTreeNode("enc", data=self.encData)
encNode["type"] = self.encType
encNode["v"] = str(self.encVersion)
node.addChild(encNode)
return node
def setUp(self):
super(VCardMediaMessageProtocolEntityTest, self).setUp()
self.ProtocolEntity = VCardMediaMessageProtocolEntity
vcardNode = ProtocolTreeNode("vcard", {"name": "abc"}, None,
"VCARD_DATA")
mediaNode = self.node.getChild("media")
mediaNode["type"] = "vcard"
mediaNode.addChild(vcardNode)
def toProtocolTreeNode(self):
node = super(CreateGroupsIqProtocolEntity, self).toProtocolTreeNode()
node.addChild(
ProtocolTreeNode("group", {
"action": "create",
"subject": self.subject
}))
return node
def setUp(self):
super(ResultRequestUploadIqProtocolEntityTest, self).setUp()
mediaNode = ProtocolTreeNode("encr_media", {
"url": "url",
"ip": "1.2.3.4"
})
self.ProtocolEntity = ResultRequestUploadIqProtocolEntity
self.node.addChild(mediaNode)
def setUp(self):
super(SetPictureNotificationProtocolEntityTest, self).setUp()
self.ProtocolEntity = SetPictureNotificationProtocolEntity
setNode = ProtocolTreeNode("set", {
"jid": "SET_JID",
"id": "123"
}, None, None)
self.node.addChild(setNode)
def setUp(self):
super(CreateGroupsIqProtocolEntityTest, self).setUp()
self.ProtocolEntity = CreateGroupsIqProtocolEntity
groupNode = ProtocolTreeNode("group", {
"action": "create",
"subject": "group_subj"
})
self.node.addChild(groupNode)
def toProtocolTreeNode(self):
node = super(ResultGetPictureIqProtocolEntity,
self).toProtocolTreeNode()
pictureNode = ProtocolTreeNode(
{"type": "preview" if self.isPreview() else "image"},
data=self.getPictureData())
node.addChild(pictureNode)
return node
def toProtocolTreeNode(self):
node = super(OutgoingReceiptProtocolEntity, self).toProtocolTreeNode()
if self.read:
node.setAttribute("type", "read")
if self.participant:
node.setAttribute("participant", self.participant)
if self.callId:
offer = ProtocolTreeNode("offer", {"call-id": self.callId})
node.addChild(offer)
node.setAttribute("to", self.to)
if len(self.messageIds) > 1:
listNode = ProtocolTreeNode("list")
listNode.addChildren([ProtocolTreeNode("item", {"id": mId}) for mId in self.messageIds])
node.addChild(listNode)
return node
def toProtocolTreeNode(self):
node = super(SetPictureNotificationProtocolEntity,
self).toProtocolTreeNode()
setNode = ProtocolTreeNode("set", {
"jid": self.setJid,
"id": self.setId
}, None, None)
node.addChild(setNode)
return node
def toProtocolTreeNode(self):
node = super(VCardMediaMessageProtocolEntity,
self).toProtocolTreeNode()
mediaNode = node.getChild("media")
mediaNode["type"] = "vcard"
vcardNode = ProtocolTreeNode("vcard", {"name": self.name}, None,
self.card_data)
mediaNode.addChild(vcardNode)
return node
def toProtocolTreeNode(self):
node = super(RetryIncomingReceiptProtocolEntity,
self).toProtocolTreeNode()
retry = ProtocolTreeNode(
"retry", {
"count": str(self.count),
"id": self.getId(),
"v": str(self.v),
"t": str(self.retryTimestamp)
})
node.addChild(retry)
registration = ProtocolTreeNode(
"registration",
data=ResultGetKeysIqProtocolEntity._intToBytes(
self.remoteRegistrationId))
node.addChild(registration)
return node
def setUp(self):
self.ProtocolEntity = SuccessProtocolEntity
attribs = {
"creation": "1234",
"location": "atn",
"props": "2",
"t": "1415470561"
}
self.node = ProtocolTreeNode("success", attribs)
def nextTreeInternal(self, data):
size = self.readListSize(self.readInt8(data), data)
token = self.readInt8(data)
if token == 1:
token = self.readInt8(data)
if token == 2:
return None
tag = self.readString(token, data)
if size == 0 or tag is None:
raise ValueError("nextTree sees 0 list or null tag")
attribCount = (size - 2 + size % 2)/2
attribs = self.readAttributes(attribCount, data)
if size % 2 ==1:
return ProtocolTreeNode(tag, attribs)
read2 = self.readInt8(data)
nodeData = None
nodeChildren = None
if self.isListTag(read2):
nodeChildren = self.readList(read2, data)
elif read2 == 252:
size = self.readInt8(data)
nodeData = self.readArray(size, data)
elif read2 == 253:
size = self.readInt20(data)
nodeData = self.readArray(size, data)
elif read2 == 254:
size = self.readInt31(data)
nodeData = self.readArray(size, data)
elif read2 in (255, 251):
nodeData = self.readPacked8(read2, data)
else:
nodeData = self.readString(read2, data)
if nodeData and type(nodeData) is not str:
nodeData = "".join(map(chr, nodeData))
return ProtocolTreeNode(tag, attribs, nodeChildren, nodeData)
def setUp(self):
self.ProtocolEntity = NotificationProtocolEntity
attribs = {
"t": "12345",
"from": "from_jid",
"offline": "0",
"type": "notif_type",
"id": "message-id",
"notify": "notify_name"
}
self.node = ProtocolTreeNode("notification", attribs)
def toProtocolTreeNode(self):
node = super(SubjectGroupsNotificationProtocolEntity,
self).toProtocolTreeNode()
subjectNode = ProtocolTreeNode(
"subject", {
"s_t": str(self.getSubjectTimestamp()),
"s_o": self.getSubjectOwner(),
"subject": self.getSubject()
})
node.addChild(subjectNode)
return node
def toProtocolTreeNode(self):
node = super(ListParticipantsResultIqProtocolEntity,
self).toProtocolTreeNode()
participantNodes = [
ProtocolTreeNode("participant", {"jid": participant})
for participant in self.participantList
]
node.addChildren(participantNodes)
return node
def toProtocolTreeNode(self):
users = [ProtocolTreeNode("user", {}, None, number) for number in self.numbers]
node = super(GetSyncIqProtocolEntity, self).toProtocolTreeNode()
syncNode = node.getChild("sync")
syncNode.setAttribute("mode", self.mode)
syncNode.setAttribute("context", self.context)
syncNode.addChildren(users)
return node
def toProtocolTreeNode(self):
node = super(RetryOutgoingReceiptProtocolEntity,
self).toProtocolTreeNode()
node.setAttribute("type", "retry")
retry_attrs = {
"count": str(self.count),
"id": self.getId(),
"v": str(self.v),
"t": str(self.retry_timestamp)
}
retry = ProtocolTreeNode("retry", retry_attrs)
node.addChild(retry)
registration = ProtocolTreeNode(
"registration",
data=ResultGetKeysIqProtocolEntity._intToBytes(
self.local_registration_id))
node.addChild(registration)
return node
def setUp(self):
self.ProtocolEntity = SuccessProtocolEntity
attribs = {
"status": "active",
"kind": "free",
"creation": "1234",
"expiration": "1446578937",
"props": "2",
"t": "1415470561"
}
self.node = ProtocolTreeNode("success", attribs, None, "dummydata")
def toProtocolTreeNode(self):
node = super(IncomingReceiptProtocolEntity, self).toProtocolTreeNode()
node.setAttribute("from", self._from)
node.setAttribute("t", str(self.timestamp))
if self.offline is not None:
node.setAttribute("offline", "1" if self.offline else "0")
if self.type is not None:
node.setAttribute("type", self.type)
if self.participant is not None:
node.setAttribute("participant", self.participant)
if self.items is not None:
inodes = []
for item in self.items:
inode = ProtocolTreeNode("item", {"id": item})
inodes.append(inode)
lnode = ProtocolTreeNode("list")
lnode.addChildren(inodes)
node.addChild(lnode)
return node
def toProtocolTreeNode(self):
node = super(SetKeysIqProtocolEntity, self).toProtocolTreeNode()
identityNode = ProtocolTreeNode("identity", data = self.identityKey)
listNode = ProtocolTreeNode("list")
keyNodes = []
for keyId, pk in self.preKeys.items():
keyNode = ProtocolTreeNode("key")
keyNode.addChild(ProtocolTreeNode("id", data = keyId))
keyNode.addChild(ProtocolTreeNode("value", data = pk))
keyNodes.append(keyNode)
listNode.addChildren(keyNodes)
regNode = ProtocolTreeNode("registration", data = self.registration)
typeNode = ProtocolTreeNode("type", data = chr(self.djbType))
_id, val, signature = self.signedPreKey
skeyNode = ProtocolTreeNode("skey", children = [
ProtocolTreeNode("id", data = _id),
ProtocolTreeNode("value", data = val),
ProtocolTreeNode("signature", data = signature)
])
node.addChildren([
listNode,
identityNode,
regNode,
typeNode,
skeyNode
])
return node
def toProtocolTreeNode(self):
node = super(InfoGroupsResultIqProtocolEntity, self).toProtocolTreeNode()
groupNode = ProtocolTreeNode("group", {
"subject": self.getSubject(),
"creation": str(self.getCreationTimestamp()),
"creator": self.getCreatorJid(),
"s_t": self.getSubjectTimestamp(),
"s_o": self.getSubjectOwnerJid(),
"id": self.getGroupId()
})
participants = []
for jid, _type in self.getParticipants().items():
pnode = ProtocolTreeNode("participant", {"jid": jid})
if _type:
pnode["type"] = _type
participants.append(pnode)
groupNode.addChildren(participants)
node.addChild(groupNode)
return node
def setUp(self):
super(ResultIqProtocolEntityTest, self).setUp()
self.ProtocolEntity = ResultGetKeysIqProtocolEntity
listNode = ProtocolTreeNode("list")
self.node.addChild(listNode)
for i in range(0, 1):
userNode = ProtocolTreeNode("user", {"jid": "user_%s@%s" % (i, YowConstants.WHATSAPP_SERVER)})
listNode.addChild(userNode)
registrationNode = ProtocolTreeNode("registration",
data = ResultGetKeysIqProtocolEntity._intToBytes(
KeyHelper.generateRegistrationId()))
typeNode = ProtocolTreeNode("type", data = ResultGetKeysIqProtocolEntity._intToBytes(Curve.DJB_TYPE))
identityKeyPair = KeyHelper.generateIdentityKeyPair()
identityNode = ProtocolTreeNode("identity", data=identityKeyPair.getPublicKey().getPublicKey().getPublicKey())
signedPreKey = KeyHelper.generateSignedPreKey(identityKeyPair, i)
signedPreKeyNode = ProtocolTreeNode("skey")
signedPreKeyNode_idNode = ProtocolTreeNode("id",
data = ResultGetKeysIqProtocolEntity._intToBytes(
signedPreKey.getId()))
signedPreKeyNode_valueNode = ProtocolTreeNode("value",
data = signedPreKey.getKeyPair().getPublicKey().getPublicKey())
signedPreKeyNode_sigNode = ProtocolTreeNode("signature",
data = signedPreKey.getSignature())
signedPreKeyNode.addChildren([signedPreKeyNode_idNode, signedPreKeyNode_valueNode, signedPreKeyNode_sigNode])
preKey = KeyHelper.generatePreKeys(i * 10, 1)[0]
preKeyNode = ProtocolTreeNode("key")
preKeyNode_idNode = ProtocolTreeNode("id", data = ResultGetKeysIqProtocolEntity._intToBytes(preKey.getId()))
preKeyNode_valNode = ProtocolTreeNode("value", data = preKey.getKeyPair().getPublicKey().getPublicKey())
preKeyNode.addChildren([preKeyNode_idNode, preKeyNode_valNode])
userNode.addChildren([
registrationNode,
typeNode,
identityNode,
signedPreKeyNode,
preKeyNode
])
def receive(self, node):
if ProtocolTreeNode.tagEquals(node, "message") and node.getAttributeValue("type") == "media":
self.downloadMedia(node.getChild("media").getAttributeValue("url"))
else:
self.toUpper(node)
def setUp(self):
self.ProtocolEntity = ChatstateProtocolEntity
self.node = ProtocolTreeNode("chatstate")
self.node.addChild(ProtocolTreeNode('composing'))
def toProtocolTreeNode(self):
node = super(ResultGetKeysIqProtocolEntity, self).toProtocolTreeNode()
listNode = ProtocolTreeNode("list")
node.addChild(listNode)
for jid, preKeyBundle in self.preKeyBundleMap.items():
userNode = ProtocolTreeNode("user", {"jid": jid})
registrationNode = ProtocolTreeNode("registration", data = self.__class__._intToBytes(preKeyBundle.getRegistrationId()))
typeNode = ProtocolTreeNode("type", data = self.__class__._intToBytes(Curve.DJB_TYPE))
identityNode = ProtocolTreeNode("identity", data = preKeyBundle.getIdentityKey().getPublicKey().getPublicKey())
skeyNode = ProtocolTreeNode("skey")
skeyNode_idNode = ProtocolTreeNode("id", data=self.__class__._intToBytes(preKeyBundle.getSignedPreKeyId()))
skeyNode_valueNode = ProtocolTreeNode("value", data=preKeyBundle.getSignedPreKey().getPublicKey())
skeyNode_signatureNode = ProtocolTreeNode("signature", data=preKeyBundle.getSignedPreKeySignature())
skeyNode.addChildren([skeyNode_idNode, skeyNode_valueNode, skeyNode_signatureNode])
preKeyNode = ProtocolTreeNode("key")
preKeyNode_idNode = ProtocolTreeNode("id", data = self.__class__._intToBytes(preKeyBundle.getPreKeyId()))
preKeyNode_valueNode = ProtocolTreeNode("value", data= preKeyBundle.getPreKey().getPublicKey())
preKeyNode.addChildren([preKeyNode_idNode, preKeyNode_valueNode])
userNode.addChildren([
registrationNode,
typeNode,
identityNode,
skeyNode,
preKeyNode
])
listNode.addChild(userNode)
return node
def appendPlainNode(self, node, plaintext):
if node.getAttributeValue("type") == 'text':
bodyNode = ProtocolTreeNode("body", data = plaintext)
elif node.getAttributeValue("type") == 'media':
#decode schema from encrypted message
if node.getChild("enc").getAttributeValue("mediatype") == 'image':
media = encrypted_media_pb2.MediaImage()
media.ParseFromString(plaintext)
bodyNode = ProtocolTreeNode("media", data = media.preview)
bodyNode.setAttribute("type", node.getChild("enc").getAttributeValue("mediatype"))
bodyNode.setAttribute("size", str(media.length))
bodyNode.setAttribute("width", str(media.width))
bodyNode.setAttribute("height", str(media.height))
bodyNode.setAttribute("encoding", "unknown")
bodyNode.setAttribute("caption", media.caption)
bodyNode.setAttribute("mimetype", media.mimetype)
bodyNode.setAttribute("filehash", base64.b64encode(media.sha256))
bodyNode.setAttribute("url", media.url)
bodyNode.setAttribute("file", "unknown")
bodyNode.setAttribute("refkey", base64.b64encode(media.refkey))
elif node.getChild("enc").getAttributeValue("mediatype") == 'document':
media = encrypted_media_pb2.MediaDocument()
media.ParseFromString(plaintext)
bodyNode = ProtocolTreeNode("media", data = media.preview)
bodyNode.setAttribute("type", node.getChild("enc").getAttributeValue("mediatype"))
bodyNode.setAttribute("url", media.url)
bodyNode.setAttribute("mimetype", media.mimetype)
bodyNode.setAttribute("filehash", base64.b64encode(media.sha256))
bodyNode.setAttribute("name", media.name)
bodyNode.setAttribute("size", str(media.length))
bodyNode.setAttribute("refkey", base64.b64encode(media.refkey))
bodyNode.setAttribute("file", media.filename)
elif node.getChild("enc").getAttributeValue("mediatype") == 'location':
media = encrypted_media_pb2.MediaLocation()
media.ParseFromString(plaintext)
bodyNode = ProtocolTreeNode("media", data = media.preview)
bodyNode.setAttribute("type", node.getChild("enc").getAttributeValue("mediatype"))
bodyNode.setAttribute("latitude", str(media.latitude))
bodyNode.setAttribute("longitude", str(media.longitude))
bodyNode.setAttribute("name", media.name)
bodyNode.setAttribute("url", media.url)
bodyNode.setAttribute("encoding","unknown")
bodyNode.setAttribute("description", media.description)
elif node.getChild("enc").getAttributeValue("mediatype") == 'contact':
media = encrypted_media_pb2.MediaContact()
media.ParseFromString(plaintext)
bodyNode = ProtocolTreeNode("media", data = media.data)
bodyNode.setAttribute("type", node.getChild("enc").getAttributeValue("mediatype"))
bodyNode.setAttribute("name", media.name)
elif node.getChild("enc").getAttributeValue("mediatype") == 'url':
media = encrypted_media_pb2.MediaUrl()
media.ParseFromString(plaintext)
bodyNode = ProtocolTreeNode("media", data = media.preview)
bodyNode.setAttribute("type", node.getChild("enc").getAttributeValue("mediatype"))
bodyNode.setAttribute("message", media.message)
bodyNode.setAttribute("url", media.url)
bodyNode.setAttribute("description", media.description)
bodyNode.setAttribute("title", media.title)
else:
raise "Unmanaged media type"
else:
raise "Unmanaged data type"
logger.debug(bodyNode)
node.addChild(bodyNode)
