libervia-backend: sat/memory/encryption.py comparison

comparison sat/memory/encryption.py @ 3028:ab2696e34d29

Python 3 port: /!\ this is a huge commit /!\ starting from this commit, SàT is needs Python 3.6+ /!\ SàT maybe be instable or some feature may not work anymore, this will improve with time This patch port backend, bridge and frontends to Python 3. Roughly this has been done this way: - 2to3 tools has been applied (with python 3.7) - all references to python2 have been replaced with python3 (notably shebangs) - fixed files not handled by 2to3 (notably the shell script) - several manual fixes - fixed issues reported by Python 3 that where not handled in Python 2 - replaced "async" with "async_" when needed (it's a reserved word from Python 3.7) - replaced zope's "implements" with @implementer decorator - temporary hack to handle data pickled in database, as str or bytes may be returned, to be checked later - fixed hash comparison for password - removed some code which is not needed anymore with Python 3 - deactivated some code which needs to be checked (notably certificate validation) - tested with jp, fixed reported issues until some basic commands worked - ported Primitivus (after porting dependencies like urwid satext) - more manual fixes

author	Goffi <goffi@goffi.org>
date	Tue, 13 Aug 2019 19:08:41 +0200
parents	c161a294fffd
children	118d91c932a7

comparison

equal deleted inserted replaced

-:ff5bcb12ae60
+:ab2696e34d29
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # SAT: a jabber client
 # Copyright (C) 2009-2019 Jérôme Poisson (goffi@goffi.org)
 namespace=namespace,
 priority=priority,
 directed=directed)
 cls.plugins.append(plugin)
 cls.plugins.sort(key=lambda p: p.priority)
-log.info(_(u"Encryption plugin registered: {name}").format(name=name))
+log.info(_("Encryption plugin registered: {name}").format(name=name))
 @classmethod
 def getPlugins(cls):
 return cls.plugins
 def getPlugin(cls, namespace):
 try:
 return next(p for p in cls.plugins if p.namespace == namespace)
 except StopIteration:
 raise exceptions.NotFound(_(
-u"Can't find requested encryption plugin: {namespace}").format(
+"Can't find requested encryption plugin: {namespace}").format(
 namespace=namespace))
 @classmethod
 def getNamespaces(cls):
 """Get available plugin namespaces"""
 """
 for p in cls.plugins:
 if p.name.lower() == name.lower():
 return p.namespace
 raise exceptions.NotFound(_(
-u"Can't find a plugin with the name \"{name}\".".format(
+"Can't find a plugin with the name \"{name}\".".format(
 name=name)))
 def getBridgeData(self, session):
 """Retrieve session data serialized for bridge.
 @param session(dict): encryption session
 @return (unicode): serialized data for bridge
 """
 if session is None:
-return u''
+return ''
-plugin = session[u'plugin']
+plugin = session['plugin']
 bridge_data = {'name': plugin.name,
 'namespace': plugin.namespace}
-if u'directed_devices' in session:
+if 'directed_devices' in session:
-bridge_data[u'directed_devices'] = session[u'directed_devices']
+bridge_data['directed_devices'] = session['directed_devices']
 return data_format.serialise(bridge_data)
 def _startEncryption(self, plugin, entity):
 """Start encryption with a plugin
 StartEncryptionn method of plugin will be called if it exists.
 """
 try:
 start_encryption = plugin.instance.startEncryption
 except AttributeError:
-log.debug(u"No startEncryption method found for {plugin}".format(
+log.debug("No startEncryption method found for {plugin}".format(
 plugin = plugin.namespace))
 return defer.succeed(None)
 else:
 # we copy entity to avoid having the resource changed by stop_encryption
 return defer.maybeDeferred(start_encryption, self.client, copy.copy(entity))
 StopEncryptionn method of plugin will be called if it exists.
 """
 try:
 stop_encryption = plugin.instance.stopEncryption
 except AttributeError:
-log.debug(u"No stopEncryption method found for {plugin}".format(
+log.debug("No stopEncryption method found for {plugin}".format(
 plugin = plugin.namespace))
 return defer.succeed(None)
 else:
 # we copy entity to avoid having the resource changed by stop_encryption
 return defer.maybeDeferred(stop_encryption, self.client, copy.copy(entity))
 None to select automatically an algorithm
 @param replace(bool): if True and an encrypted session already exists,
 it will be replaced by the new one
 """
 if not self.plugins:
-raise exceptions.NotFound(_(u"No encryption plugin is registered, "
+raise exceptions.NotFound(_("No encryption plugin is registered, "
-u"an encryption session can't be started"))
+"an encryption session can't be started"))
 if namespace is None:
 plugin = self.plugins[0]
 else:
 plugin = self.getPlugin(namespace)
 bare_jid = entity.userhostJID()
 if bare_jid in self._sessions:
 # we have already an encryption session with this contact
-former_plugin = self._sessions[bare_jid][u"plugin"]
+former_plugin = self._sessions[bare_jid]["plugin"]
 if former_plugin.namespace == namespace:
-log.info(_(u"Session with {bare_jid} is already encrypted with {name}. "
+log.info(_("Session with {bare_jid} is already encrypted with {name}. "
-u"Nothing to do.").format(
+"Nothing to do.").format(
 bare_jid=bare_jid, name=former_plugin.name))
 return
 if replace:
 # there is a conflict, but replacement is requested
 # so we stop previous encryption to use new one
 del self._sessions[bare_jid]
 yield self._stopEncryption(former_plugin, entity)
 else:
-msg = (_(u"Session with {bare_jid} is already encrypted with {name}. "
+msg = (_("Session with {bare_jid} is already encrypted with {name}. "
-u"Please stop encryption session before changing algorithm.")
+"Please stop encryption session before changing algorithm.")
 .format(bare_jid=bare_jid, name=plugin.name))
 log.warning(msg)
 raise exceptions.ConflictError(msg)
 data = {"plugin": plugin}
 if plugin.directed:
 if not entity.resource:
 entity.resource = self.host.memory.getMainResource(self.client, entity)
 if not entity.resource:
 raise exceptions.NotFound(
-_(u"No resource found for {destinee}, can't encrypt with {name}")
+_("No resource found for {destinee}, can't encrypt with {name}")
 .format(destinee=entity.full(), name=plugin.name))
-log.info(_(u"No resource specified to encrypt with {name}, using "
+log.info(_("No resource specified to encrypt with {name}, using "
-u"{destinee}.").format(destinee=entity.full(),
+"{destinee}.").format(destinee=entity.full(),
 name=plugin.name))
 # indicate that we encrypt only for some devices
-directed_devices = data[u'directed_devices'] = [entity.resource]
+directed_devices = data['directed_devices'] = [entity.resource]
 elif entity.resource:
-raise ValueError(_(u"{name} encryption must be used with bare jids."))
+raise ValueError(_("{name} encryption must be used with bare jids."))
 yield self._startEncryption(plugin, entity)
 self._sessions[entity.userhostJID()] = data
-log.info(_(u"Encryption session has been set for {entity_jid} with "
+log.info(_("Encryption session has been set for {entity_jid} with "
-u"{encryption_name}").format(
+"{encryption_name}").format(
 entity_jid=entity.full(), encryption_name=plugin.name))
 self.host.bridge.messageEncryptionStarted(
 entity.full(),
 self.getBridgeData(data),
 self.client.profile)
-msg = D_(u"Encryption session started: your messages with {destinee} are "
+msg = D_("Encryption session started: your messages with {destinee} are "
-u"now end to end encrypted using {name} algorithm.").format(
+"now end to end encrypted using {name} algorithm.").format(
 destinee=entity.full(), name=plugin.name)
-directed_devices = data.get(u'directed_devices')
+directed_devices = data.get('directed_devices')
 if directed_devices:
-msg += u"\n" + D_(u"Message are encrypted only for {nb_devices} device(s): "
+msg += "\n" + D_("Message are encrypted only for {nb_devices} device(s): "
-u"{devices_list}.").format(
+"{devices_list}.").format(
 nb_devices=len(directed_devices),
-devices_list = u', '.join(directed_devices))
+devices_list = ', '.join(directed_devices))
 self.client.feedback(bare_jid, msg)
 @defer.inlineCallbacks
 def stop(self, entity, namespace=None):
 when specified, used to check we stop the right encryption session
 """
 session = self.getSession(entity.userhostJID())
 if not session:
 raise failure.Failure(
-exceptions.NotFound(_(u"There is no encryption session with this "
+exceptions.NotFound(_("There is no encryption session with this "
-u"entity.")))
+"entity.")))
 plugin = session['plugin']
 if namespace is not None and plugin.namespace != namespace:
 raise exceptions.InternalError(_(
-u"The encryption session is not run with the expected plugin: encrypted "
+"The encryption session is not run with the expected plugin: encrypted "
-u"with {current_name} and was expecting {expected_name}").format(
+"with {current_name} and was expecting {expected_name}").format(
-current_name=session[u'plugin'].namespace,
+current_name=session['plugin'].namespace,
 expected_name=namespace))
 if entity.resource:
 try:
-directed_devices = session[u'directed_devices']
+directed_devices = session['directed_devices']
 except KeyError:
 raise exceptions.NotFound(_(
-u"There is a session for the whole entity (i.e. all devices of the "
+"There is a session for the whole entity (i.e. all devices of the "
-u"entity), not a directed one. Please use bare jid if you want to "
+"entity), not a directed one. Please use bare jid if you want to "
-u"stop the whole encryption with this entity."))
+"stop the whole encryption with this entity."))
 try:
 directed_devices.remove(entity.resource)
 except ValueError:
-raise exceptions.NotFound(_(u"There is no directed session with this "
+raise exceptions.NotFound(_("There is no directed session with this "
-u"entity."))
+"entity."))
 else:
 if not directed_devices:
 # if we have no more directed device sessions,
 # we stop the whole session
 # see comment below for deleting session before stopping encryption
 # plugin's stopEncryption may call stop again (that's the case with OTR)
 # so we need to remove plugin from session before calling self._stopEncryption
 del self._sessions[entity.userhostJID()]
 yield self._stopEncryption(plugin, entity)
-log.info(_(u"encryption session stopped with entity {entity}").format(
+log.info(_("encryption session stopped with entity {entity}").format(
 entity=entity.full()))
 self.host.bridge.messageEncryptionStopped(
 entity.full(),
 {'name': plugin.name,
 'namespace': plugin.namespace,
 },
 self.client.profile)
-msg = D_(u"Encryption session finished: your messages with {destinee} are "
+msg = D_("Encryption session finished: your messages with {destinee} are "
-u"NOT end to end encrypted anymore.\nYour server administrators or "
+"NOT end to end encrypted anymore.\nYour server administrators or "
-u"{destinee} server administrators will be able to read them.").format(
+"{destinee} server administrators will be able to read them.").format(
 destinee=entity.full())
 self.client.feedback(entity, msg)
 def getSession(self, entity):
 must be a bare jid
 @return (dict, None): encryption session data
 None if there is not encryption for this session with this jid
 """
 if entity.resource:
-raise ValueError(u"Full jid given when expecting bare jid")
+raise ValueError("Full jid given when expecting bare jid")
 return self._sessions.get(entity)
 def getTrustUI(self, entity_jid, namespace=None):
 """Retrieve encryption UI
 """
 if namespace is None:
 session = self.getSession(entity_jid)
 if not session:
 raise exceptions.NotFound(
-u"No encryption session currently active for {entity_jid}"
+"No encryption session currently active for {entity_jid}"
 .format(entity_jid=entity_jid.full()))
 plugin = session['plugin']
 else:
 plugin = self.getPlugin(namespace)
 try:
 get_trust_ui = plugin.instance.getTrustUI
 except AttributeError:
 raise NotImplementedError(
-u"Encryption plugin doesn't handle trust management UI")
+"Encryption plugin doesn't handle trust management UI")
 else:
 return defer.maybeDeferred(get_trust_ui, self.client, entity_jid)
 ## Menus ##
 @classmethod
 def _importMenus(cls, host):
 host.importMenu(
-(D_(u"Encryption"), D_(u"unencrypted (plain text)")),
+(D_("Encryption"), D_("unencrypted (plain text)")),
 partial(cls._onMenuUnencrypted, host=host),
 security_limit=0,
-help_string=D_(u"End encrypted session"),
+help_string=D_("End encrypted session"),
 type_=C.MENU_SINGLE,
 )
 for plg in cls.getPlugins():
 host.importMenu(
-(D_(u"Encryption"), plg.name),
+(D_("Encryption"), plg.name),
 partial(cls._onMenuName, host=host, plg=plg),
 security_limit=0,
-help_string=D_(u"Start {name} session").format(name=plg.name),
+help_string=D_("Start {name} session").format(name=plg.name),
 type_=C.MENU_SINGLE,
 )
 host.importMenu(
-(D_(u"Encryption"), D_(u"⛨ {name} trust").format(name=plg.name)),
+(D_("Encryption"), D_("⛨ {name} trust").format(name=plg.name)),
 partial(cls._onMenuTrust, host=host, plg=plg),
 security_limit=0,
-help_string=D_(u"Manage {name} trust").format(name=plg.name),
+help_string=D_("Manage {name} trust").format(name=plg.name),
 type_=C.MENU_SINGLE,
 )
 @classmethod
 def _onMenuUnencrypted(cls, data, host, profile):
 client = host.getClient(profile)
-peer_jid = jid.JID(data[u'jid']).userhostJID()
+peer_jid = jid.JID(data['jid']).userhostJID()
 d = client.encryption.stop(peer_jid)
 d.addCallback(lambda __: {})
 return d
 @classmethod
 def _onMenuName(cls, data, host, plg, profile):
 client = host.getClient(profile)
-peer_jid = jid.JID(data[u'jid'])
+peer_jid = jid.JID(data['jid'])
 if not plg.directed:
 peer_jid = peer_jid.userhostJID()
 d = client.encryption.start(peer_jid, plg.namespace, replace=True)
 d.addCallback(lambda __: {})
 return d
 @classmethod
 @defer.inlineCallbacks
 def _onMenuTrust(cls, data, host, plg, profile):
 client = host.getClient(profile)
-peer_jid = jid.JID(data[u'jid']).userhostJID()
+peer_jid = jid.JID(data['jid']).userhostJID()
 ui = yield client.encryption.getTrustUI(peer_jid, plg.namespace)
-defer.returnValue({u'xmlui': ui.toXml()})
+defer.returnValue({'xmlui': ui.toXml()})
 ## Triggers ##
 def setEncryptionFlag(self, mess_data):
 """Set "encryption" key in mess_data if session with destinee is encrypted"""

Mercurial > libervia-backend

comparison sat/memory/encryption.py @ 3028:ab2696e34d29