summaryrefslogtreecommitdiff
path: root/plugins
diff options
context:
space:
mode:
Diffstat (limited to 'plugins')
-rw-r--r--plugins/omemo_plugin.py366
1 files changed, 164 insertions, 202 deletions
diff --git a/plugins/omemo_plugin.py b/plugins/omemo_plugin.py
index daca9e8d..b396422e 100644
--- a/plugins/omemo_plugin.py
+++ b/plugins/omemo_plugin.py
@@ -10,222 +10,184 @@
"""
import os
-import asyncio
import logging
-from typing import Callable, List, Optional, Set, Tuple, Union
-from poezio.plugin import BasePlugin
-from poezio.tabs import DynamicConversationTab, StaticConversationTab, ConversationTab, MucTab
+from poezio.plugin_e2ee import E2EEPlugin
from poezio.xdg import DATA_HOME
-from slixmpp import JID
-from slixmpp.plugins.xep_0384.plugin import MissingOwnKey
+from slixmpp.stanza import Message
+from slixmpp_omemo import PluginCouldNotLoad, MissingOwnKey, NoAvailableSession
+from slixmpp_omemo import UndecidedException, UntrustedException, EncryptionPrepareException
+import slixmpp_omemo
log = logging.getLogger(__name__)
-class Plugin(BasePlugin):
+class Plugin(E2EEPlugin):
"""OMEMO (XEP-0384) Plugin"""
- _enabled_jids = set() # type: Set[JID]
- def init(self):
- self.info = lambda i: self.api.information(i, 'Info')
- self.xmpp = self.core.xmpp
-
- data_dir = os.path.join(DATA_HOME, 'omemo')
- os.makedirs(data_dir, exist_ok=True)
-
- self.xmpp.register_plugin(
- 'xep_0384', {
- 'data_dir': data_dir,
- })
-
- self.api.add_command(
- 'omemo',
- self.command_status,
- help='Display contextual information',
- )
-
- ConversationTab.add_information_element('omemo', self.display_encryption_status)
- MucTab.add_information_element('omemo', self.display_encryption_status)
-
- self.api.add_command(
- 'omemo_enable',
- self.command_enable,
- help='Enable OMEMO encryption',
- )
-
- self.api.add_command(
- 'omemo_disable',
- self.command_disable,
- help='Disable OMEMO encryption',
- )
-
- self.api.add_command(
- 'encrypted_message',
- self.send_message,
- help='Send OMEMO encrypted message',
- )
-
- self.api.add_event_handler(
- 'conversation_say_after',
- self.on_conversation_say_after,
- )
-
- self.api.add_event_handler(
- 'conversation_msg',
- self.on_conversation_msg,
- )
-
- def cleanup(self) -> None:
- ConversationTab.remove_information_element('omemo')
- MucTab.remove_information_element('omemo')
-
- def display_encryption_status(self, jid: JID) -> str:
- """
- Return information to display in the infobar if OMEMO is enabled
- for the JID.
- """
-
- if jid in self._enabled_jids:
- return " OMEMO"
- return ""
-
- def command_status(self, _args):
- """Display contextual information depending on currenttab."""
- tab = self.api.current_tab()
- self.info('OMEMO!')
- self.info("My device id: %d" % self.xmpp['xep_0384'].my_device_id())
-
- def _jid_from_context(self, jid: Optional[Union[str, JID]]) -> Tuple[Optional[JID], bool]:
- """
- Get bare JID from context if not specified
-
- Return a tuple with the JID and a bool specifying that the JID
- corresponds to the current tab.
- """
-
- tab = self.api.current_tab()
-
- tab_jid = None
- chat_tabs = (DynamicConversationTab, StaticConversationTab, ConversationTab, MucTab)
- if isinstance(tab, chat_tabs):
- tab_jid = JID(tab.name).bare
-
- # If current tab has a JID, use it if none is specified
- if not jid and tab_jid is not None:
- jid = tab_jid
-
- # We might not have found a JID at this stage. No JID provided and not
- # in a tab with a JID (InfoTab etc.).
- # If we do, make we
- if jid:
- # XXX: Ugly. We don't know if 'jid' is a str or a JID. And we want
- # to return a bareJID. We could change the JID API to allow us to
- # clear the resource one way or another.
- jid = JID(JID(jid).bare)
- else:
- jid = None
-
- return (jid, tab_jid is not None and tab_jid == jid)
-
- def command_enable(self, jid: Optional[str]) -> None:
- """
- Enable JID to use OMEMO with.
-
- Use current tab JID is none is specified. Refresh the tab if JID
- corresponds to the one being added.
- """
-
- jid, current_tab = self._jid_from_context(jid)
- if jid is None:
- return None
-
- if jid not in self._enabled_jids:
- self.info('OMEMO enabled for %s' % jid)
- self._enabled_jids.add(jid)
-
- # Refresh tab if JID matches
- if current_tab:
- self.api.current_tab().refresh()
-
- return None
+ encryption_name = 'omemo'
+ eme_ns = slixmpp_omemo.OMEMO_BASE_NS
+ replace_body_with_eme = True
+ stanza_encryption = False
- def command_disable(self, jid: Optional[str]) -> None:
- """
- Enable JID to use OMEMO with.
+ encrypted_tags = [
+ (slixmpp_omemo.OMEMO_BASE_NS, 'payload'),
+ ]
- Use current tab JID is none is specified. Refresh the tab if JID
- corresponds to the one being added.
- """
+ def init(self) -> None:
+ super().init()
- jid, current_tab = self._jid_from_context(jid)
- if jid is None:
- return None
+ self.info = lambda i: self.api.information(i, 'Info')
- if jid in self._enabled_jids:
- self.info('OMEMO disabled for %s' % jid)
- self._enabled_jids.remove(jid)
+ data_dir = os.path.join(DATA_HOME, 'omemo')
+ os.makedirs(data_dir, exist_ok=True)
- # Refresh tab if JID matches
- if current_tab:
- self.api.current_tab().refresh()
+ try:
+ self.core.xmpp.register_plugin(
+ 'xep_0384', {
+ 'data_dir': data_dir,
+ },
+ module=slixmpp_omemo,
+ ) # OMEMO
+ except (PluginCouldNotLoad,):
+ log.exception('And error occured when loading the omemo plugin.')
+
+# def send_message(self, _args):
+# asyncio.ensure_future(
+# self._send_encrypted_message(
+# "Hello Encrypted World!",
+# [JID('pep@bouah.net'), JID('test@bouah.net')],
+# mto=JID('test@bouah.net'),
+# mtype='chat',
+# ),
+# )
+#
+# async def _send_encrypted_message(
+# self,
+# payload: str,
+# recipients: List[JID],
+# mto: Optional[JID] = None,
+# mtype: Optional[str] = 'chat',
+# ) -> None:
+# try:
+# encrypted = await self.xmpp['xep_0384'].encrypt_message(payload, recipients)
+# except EncryptionPrepareException as e:
+# log.debug('Failed to encrypt message: %r', e)
+# return None
+# msg = self.core.xmpp.make_message(mto, mtype=mtype)
+# msg['body'] = 'This message is encrypted with Legacy OMEMO (eu.siacs.conversations.axolotl)'
+# msg['eme']['namespace'] = 'eu.siacs.conversations.axolotl'
+# msg.append(encrypted)
+# log.debug('BAR: message: %r', msg)
+# msg.send()
+# return None
+#
+# def on_conversation_say_after(
+# self,
+# message: Message,
+# tabs: Union[DynamicConversationTab, StaticConversationTab, ConversationTab, MucTab],
+# ) -> None:
+# """
+# Outbound messages
+# """
+#
+# # Check encryption status with the contact, if enabled, add
+# # ['omemo_encrypt'] attribute to message and send. Maybe delete
+# # ['body'] and tab.add_message ourselves to specify typ=0 so messages
+# # are not logged.
+#
+# fromjid = message['from']
+# if fromjid not in self._enabled_jids:
+# return None
+#
+# self.xmpp['xep_0384'].encrypt_message(message)
+# return None
+
+ def display_error(self, txt) -> None:
+ self.api.information(txt, 'Error')
+
+ def decrypt(self, message: Message, tab, allow_untrusted=False) -> None:
+
+ body = None
+ allow_untrusted = False
+ try:
+ body = self.core.xmpp['xep_0384'].decrypt_message(message, allow_untrusted)
+ except (MissingOwnKey,):
+ # The message is missing our own key, it was not encrypted for
+ # us, and we can't decrypt it.
+ self.display_error(
+ 'I can\'t decrypt this message as it is not encrypted for me.'
+ )
+ except (NoAvailableSession,) as exn:
+ # We received a message from that contained a session that we
+ # don't know about (deleted session storage, etc.). We can't
+ # decrypt the message, and it's going to be lost.
+ # Here, as we need to initiate a new encrypted session, it is
+ # best if we send an encrypted message directly. XXX: Is it
+ # where we talk about self-healing messages?
+ self.display_error(
+ 'I can\'t decrypt this message as it uses an encrypted '
+ 'session I don\'t know about.',
+ )
+ except (UndecidedException, UntrustedException) as exn:
+ # We received a message from an untrusted device. We can
+ # choose to decrypt the message nonetheless, with the
+ # `allow_untrusted` flag on the `decrypt_message` call, which
+ # we will do here. This is only possible for decryption,
+ # encryption will require us to decide if we trust the device
+ # or not. Clients _should_ indicate that the message was not
+ # trusted, or in undecided state, if they decide to decrypt it
+ # anyway.
+ self.display_error(
+ "Your device '%s' is not in my trusted devices." % exn.device,
+ )
+ # We resend, setting the `allow_untrusted` parameter to True.
+ self.decrypt(message, tab, allow_untrusted=True)
+ except (EncryptionPrepareException,):
+ # Slixmpp tried its best, but there were errors it couldn't
+ # resolve. At this point you should have seen other exceptions
+ # and given a chance to resolve them already.
+ self.display_error('I was not able to decrypt the message.')
+ except (Exception,) as exn:
+ self.display_error('An error occured while attempting decryption.\n%r' % exn)
+ raise
+
+ if body is not None:
+ message['body'] = body
+
+ async def encrypt(self, message: Message, _tab) -> None:
+ mto = message['from']
+ mtype = message['type']
+ body = message['body']
+
+ while True:
+ try:
+ # `encrypt_message` excepts the plaintext to be sent, a list of
+ # bare JIDs to encrypt to, and optionally a dict of problems to
+ # expect per bare JID.
+ #
+ # Note that this function returns an `<encrypted/>` object,
+ # and not a full Message stanza. This combined with the
+ # `recipients` parameter that requires for a list of JIDs,
+ # allows you to encrypt for 1:1 as well as groupchats (MUC).
+ #
+ # TODO: Document expect_problems
+ # TODO: Handle multiple recipients (MUCs)
+ recipients = [mto]
+ encrypt = await self.core.xmpp['xep_0384'].encrypt_message(body, recipients)
+ message.append(encrypt)
+ except UndecidedException as exn:
+ # The library prevents us from sending a message to an
+ # untrusted/undecided barejid, so we need to make a decision here.
+ # This is where you prompt your user to ask what to do. In
+ # this bot we will automatically trust undecided recipients.
+ self.core.xmpp['xep_0384'].trust(exn.bare_jid, exn.device, exn.ik)
+ # TODO: catch NoEligibleDevicesException and MissingBundleException
+ except Exception as exn:
+ await self.display_error(
+ 'An error occured while attempting to encrypt.\n%r' % exn,
+ )
+ raise
return None
-
- def send_message(self, _args):
- asyncio.ensure_future(
- self._send_message(
- "Hello Encrypted World!",
- [JID('some@jid')],
- mto=JID('some@jid'),
- mtype='chat',
- ),
- )
-
- async def _send_message(
- self,
- payload: str,
- recipients: List[JID],
- mto: Optional[JID] = None,
- mtype: Optional[str] = 'chat',
- ) -> None:
- encrypted = await self.xmpp['xep_0384'].encrypt_message(payload, recipients)
- msg = self.core.xmpp.make_message(mto, mtype=mtype)
- msg['body'] = 'This message is encrypted with Legacy OMEMO (eu.siacs.conversations.axolotl)'
- msg['eme']['namespace'] = 'eu.siacs.conversations.axolotl'
- msg.append(encrypted)
- log.debug('BAR: message: %r', msg)
- msg.send()
-
- def on_conversation_say_after(self, message, tab):
- """
- Outbound messages
- """
-
- # Check encryption status globally and to the contact, if enabled, add
- # ['omemo_encrypt'] attribute to message and send. Maybe delete
- # ['body'] and tab.add_message ourselves to specify typ=0 so messages
- # are not logged.
-
- fromjid = message['from']
- self.xmpp['xep_0384'].encrypt_message(message)
-
- def on_conversation_msg(self, message, _tab):
- """
- Inbound messages
- """
-
- # Check if encrypted, and if so replace message['body'] with
- # plaintext.
-
- self.info('Foo2')
- if self.xmpp['xep_0384'].is_encrypted(message):
- try:
- body = self.xmpp['xep_0384'].decrypt_message(message)
- except (MissingOwnKey,):
- log.debug("The following message is missing our key;"
- "Couldn't decrypt: %r", message)
- return None
- message['body'] = body.decode("utf8")
- return None