hueso/gajim-plugins
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cq: Format with black and isort

Browse Source
This commit is contained in:
Philipp Hörist
2025-01-25 19:15:37 +01:00
parent e6e71d82bf
commit 841b1fb25e
44 changed files with 1641 additions and 1660 deletions
Download Patch File Download Diff File Expand all files Collapse all files

195
pgp/modules/pgp_legacy.py
View File

@@ -15,57 +15,55 @@
# along with PGP Gajim Plugin. If not, see <http://www.gnu.org/licenses/>.
import os
import time
import threading
import time
import nbxmpp
from gi.repository import GLib
from nbxmpp.namespaces import Namespace
from nbxmpp.protocol import Message
from nbxmpp.structs import EncryptionData
from nbxmpp.structs import StanzaHandler
from gi.repository import GLib
from gajim.common import app
from gajim.common.const import Trust
from gajim.common.events import MessageNotSent
from gajim.common.structs import OutgoingMessage
from gajim.common.modules.base import BaseModule
from gajim.common.structs import OutgoingMessage
from gajim.plugins.plugins_i18n import _
from pgp.backend.python_gnupg import PGP
from pgp.backend.store import KeyStore
from pgp.exceptions import KeyMismatch
from pgp.exceptions import NoKeyIdFound
from pgp.exceptions import SignError
from pgp.modules.events import PGPFileEncryptionError
from pgp.modules.events import PGPNotTrusted
from pgp.modules.util import prepare_stanza
from pgp.backend.store import KeyStore
from pgp.exceptions import SignError
from pgp.exceptions import KeyMismatch
from pgp.exceptions import NoKeyIdFound
# Module name
name = 'PGPLegacy'
name = "PGPLegacy"
zeroconf = True
ENCRYPTION_NAME = 'PGP'
ENCRYPTION_NAME = "PGP"
ALLOWED_TAGS = [
('request', Namespace.RECEIPTS),
('active', Namespace.CHATSTATES),
('gone', Namespace.CHATSTATES),
('inactive', Namespace.CHATSTATES),
('paused', Namespace.CHATSTATES),
('composing', Namespace.CHATSTATES),
('markable', Namespace.CHATMARKERS),
('no-store', Namespace.HINTS),
('store', Namespace.HINTS),
('no-copy', Namespace.HINTS),
('no-permanent-store', Namespace.HINTS),
('replace', Namespace.CORRECT),
('thread', None),
('reply', Namespace.REPLY),
('fallback', Namespace.FALLBACK),
('origin-id', Namespace.SID),
('reactions', Namespace.REACTIONS),
("request", Namespace.RECEIPTS),
("active", Namespace.CHATSTATES),
("gone", Namespace.CHATSTATES),
("inactive", Namespace.CHATSTATES),
("paused", Namespace.CHATSTATES),
("composing", Namespace.CHATSTATES),
("markable", Namespace.CHATMARKERS),
("no-store", Namespace.HINTS),
("store", Namespace.HINTS),
("no-copy", Namespace.HINTS),
("no-permanent-store", Namespace.HINTS),
("replace", Namespace.CORRECT),
("thread", None),
("reply", Namespace.REPLY),
("fallback", Namespace.FALLBACK),
("origin-id", Namespace.SID),
("reactions", Namespace.REACTIONS),
]
@@ -74,21 +72,26 @@ class PGPLegacy(BaseModule):
BaseModule.__init__(self, client, plugin=True)
self.handlers = [
StanzaHandler(name='message',
callback=self._message_received,
ns=Namespace.ENCRYPTED,
priority=9),
StanzaHandler(name='presence',
callback=self._on_presence_received,
ns=Namespace.SIGNED,
priority=48),
StanzaHandler(
name="message",
callback=self._message_received,
ns=Namespace.ENCRYPTED,
priority=9,
),
StanzaHandler(
name="presence",
callback=self._on_presence_received,
ns=Namespace.SIGNED,
priority=48,
),
]
self.own_jid = self._client.get_own_jid()
self._pgp = PGP()
self._store = KeyStore(self._account, self.own_jid, self._log,
self._pgp.list_keys)
self._store = KeyStore(
self._account, self.own_jid, self._log, self._pgp.list_keys
)
self._always_trust = []
self._presence_fingerprint_store = {}
@@ -112,7 +115,7 @@ class PGPLegacy(BaseModule):
key_data = self.get_contact_key_data(jid)
if key_data is None:
return False
key_id = key_data['key_id']
key_id = key_data["key_id"]
announced_fingerprint = self._presence_fingerprint_store.get(jid)
if announced_fingerprint is None:
@@ -130,24 +133,31 @@ class PGPLegacy(BaseModule):
fingerprint = self._pgp.verify(properties.status, properties.signed)
if fingerprint is None:
self._log.info('Presence from %s was signed but no corresponding '
'key was found', jid)
self._log.info(
"Presence from %s was signed but no corresponding " "key was found", jid
)
return
self._presence_fingerprint_store[jid] = fingerprint
self._log.info('Presence from %s was verified successfully, '
'fingerprint: %s', jid, fingerprint)
self._log.info(
"Presence from %s was verified successfully, " "fingerprint: %s",
jid,
fingerprint,
)
key_data = self.get_contact_key_data(jid)
if key_data is None:
self._log.info('No key assigned for contact: %s', jid)
self._log.info("No key assigned for contact: %s", jid)
return
if key_data['key_id'] != fingerprint:
self._log.warning('Fingerprint mismatch, '
'Presence was signed with fingerprint: %s, '
'Assigned key fingerprint: %s',
fingerprint, key_data['key_id'])
if key_data["key_id"] != fingerprint:
self._log.warning(
"Fingerprint mismatch, "
"Presence was signed with fingerprint: %s, "
"Assigned key fingerprint: %s",
fingerprint,
key_data["key_id"],
)
return
def _message_received(self, _con, stanza, properties):
@@ -155,15 +165,13 @@ class PGPLegacy(BaseModule):
return
remote_jid = properties.remote_jid
self._log.info('Message received from: %s', remote_jid)
self._log.info("Message received from: %s", remote_jid)
payload = self._pgp.decrypt(properties.pgp_legacy)
prepare_stanza(stanza, payload)
properties.encrypted = EncryptionData(
protocol=ENCRYPTION_NAME,
key='Unknown',
trust=Trust.UNDECIDED
protocol=ENCRYPTION_NAME, key="Unknown", trust=Trust.UNDECIDED
)
def encrypt_message(self, con, message: OutgoingMessage, callback):
@@ -181,7 +189,9 @@ class PGPLegacy(BaseModule):
always_trust = key_id in self._always_trust
self._encrypt(con, message, [key_id, own_key_id], callback, always_trust)
def _encrypt(self, con, message: OutgoingMessage, keys, callback, always_trust: bool):
def _encrypt(
self, con, message: OutgoingMessage, keys, callback, always_trust: bool
):
result = self._pgp.encrypt(message.get_text(), keys, always_trust)
encrypted_payload, error = result
if error:
@@ -194,15 +204,18 @@ class PGPLegacy(BaseModule):
message.set_encryption(
EncryptionData(
protocol=ENCRYPTION_NAME,
key='Unknown',
key="Unknown",
trust=Trust.VERIFIED,
)
)
callback(message)
def _handle_encrypt_error(self, con, error: str, message: OutgoingMessage, keys, callback):
if error.startswith('NOT_TRUSTED'):
def _handle_encrypt_error(
self, con, error: str, message: OutgoingMessage, keys, callback
):
if error.startswith("NOT_TRUSTED"):
def on_yes(checked):
if checked:
self._always_trust.append(keys[0])
@@ -219,64 +232,67 @@ class PGPLegacy(BaseModule):
@staticmethod
def _raise_message_not_sent(con, message: OutgoingMessage, error: str):
app.ged.raise_event(
MessageNotSent(client=con,
jid=str(message.contact.jid),
message=message.get_text(),
error=_('Encryption error: %s') % error,
time=time.time()))
MessageNotSent(
client=con,
jid=str(message.contact.jid),
message=message.get_text(),
error=_("Encryption error: %s") % error,
time=time.time(),
)
)
def _create_pgp_legacy_message(self, stanza: Message, payload: str) -> None:
stanza.setBody(self._get_info_message())
stanza.setTag('x', namespace=Namespace.ENCRYPTED).setData(payload)
eme_node = nbxmpp.Node('encryption',
attrs={'xmlns': Namespace.EME,
'namespace': Namespace.ENCRYPTED})
stanza.setTag("x", namespace=Namespace.ENCRYPTED).setData(payload)
eme_node = nbxmpp.Node(
"encryption",
attrs={"xmlns": Namespace.EME, "namespace": Namespace.ENCRYPTED},
)
stanza.addChild(node=eme_node)
def sign_presence(self, presence, status):
key_data = self.get_own_key_data()
if key_data is None:
self._log.warning('No own key id found, can’t sign presence')
self._log.warning("No own key id found, can’t sign presence")
return
try:
result = self._pgp.sign(status, key_data['key_id'])
result = self._pgp.sign(status, key_data["key_id"])
except SignError as error:
self._log.warning('Sign Error: %s', error)
self._log.warning("Sign Error: %s", error)
return
# self._log.debug(self._pgp.sign.cache_info())
self._log.info('Presence signed')
presence.setTag(Namespace.SIGNED + ' x').setData(result)
self._log.info("Presence signed")
presence.setTag(Namespace.SIGNED + " x").setData(result)
@staticmethod
def _get_info_message():
msg = '[This message is *encrypted* (See :XEP:`27`)]'
lang = os.getenv('LANG')
if lang is not None and not lang.startswith('en'):
msg = "[This message is *encrypted* (See :XEP:`27`)]"
lang = os.getenv("LANG")
if lang is not None and not lang.startswith("en"):
# we're not english: one in locale and one en
msg = _('[This message is *encrypted* (See :XEP:`27`)]') + \
' (' + msg + ')'
msg = _("[This message is *encrypted* (See :XEP:`27`)]") + " (" + msg + ")"
return msg
def _get_key_ids(self, jid):
key_data = self.get_contact_key_data(jid)
if key_data is None:
raise NoKeyIdFound('No key id found for %s' % jid)
key_id = key_data['key_id']
raise NoKeyIdFound("No key id found for %s" % jid)
key_id = key_data["key_id"]
own_key_data = self.get_own_key_data()
if own_key_data is None:
raise NoKeyIdFound('Own key id not found')
own_key_id = own_key_data['key_id']
raise NoKeyIdFound("Own key id not found")
own_key_id = own_key_data["key_id"]
return key_id, own_key_id
@staticmethod
def _cleanup_stanza(message: OutgoingMessage) -> None:
''' We make sure only allowed tags are in the stanza '''
"""We make sure only allowed tags are in the stanza"""
original_stanza = message.get_stanza()
stanza = nbxmpp.Message(
to=original_stanza.getTo(),
typ=original_stanza.getType())
to=original_stanza.getTo(), typ=original_stanza.getType()
)
stanza.setID(original_stanza.getID())
stanza.setThread(original_stanza.getThread())
for tag, ns in ALLOWED_TAGS:
@@ -286,8 +302,9 @@ class PGPLegacy(BaseModule):
message.set_stanza(stanza)
def encrypt_file(self, file, callback):
thread = threading.Thread(target=self._encrypt_file_thread,
args=(file, callback))
thread = threading.Thread(
target=self._encrypt_file_thread, args=(file, callback)
)
thread.daemon = True
thread.start()
@@ -299,8 +316,7 @@ class PGPLegacy(BaseModule):
return
stream = open(file.path, "rb")
encrypted = self._pgp.encrypt_file(stream,
[key_id, own_key_id])
encrypted = self._pgp.encrypt_file(stream, [key_id, own_key_id])
stream.close()
if not encrypted:
@@ -308,7 +324,7 @@ class PGPLegacy(BaseModule):
return
file.size = len(encrypted.data)
file.set_uri_transform_func(lambda uri: '%s.pgp' % uri)
file.set_uri_transform_func(lambda uri: "%s.pgp" % uri)
file.set_encrypted_data(encrypted.data)
GLib.idle_add(callback, file)
@@ -316,5 +332,6 @@ class PGPLegacy(BaseModule):
def _on_file_encryption_error(error):
app.ged.raise_event(PGPFileEncryptionError(error=error))
def get_instance(*args, **kwargs):
return PGPLegacy(*args, **kwargs), 'PGPLegacy'
return PGPLegacy(*args, **kwargs), "PGPLegacy"