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

165
openpgp/modules/openpgp.py
View File

@@ -14,24 +14,24 @@
# You should have received a copy of the GNU General Public License
# along with OpenPGP Gajim Plugin. If not, see <http://www.gnu.org/licenses/>.
import logging
import sys
import time
import logging
from pathlib import Path
from nbxmpp.namespaces import Namespace
from nbxmpp import Node
from nbxmpp import StanzaMalformed
from nbxmpp.errors import MalformedStanzaError
from nbxmpp.errors import StanzaError
from nbxmpp.exceptions import StanzaDecrypted
from nbxmpp.modules.openpgp import create_message_stanza
from nbxmpp.modules.openpgp import create_signcrypt_node
from nbxmpp.modules.openpgp import parse_signcrypt
from nbxmpp.modules.openpgp import PGPKeyMetadata
from nbxmpp.namespaces import Namespace
from nbxmpp.structs import EncryptionData
from nbxmpp.structs import MessageProperties
from nbxmpp.structs import StanzaHandler
from nbxmpp.errors import StanzaError
from nbxmpp.errors import MalformedStanzaError
from nbxmpp.modules.openpgp import PGPKeyMetadata
from nbxmpp.modules.openpgp import parse_signcrypt
from nbxmpp.modules.openpgp import create_signcrypt_node
from nbxmpp.modules.openpgp import create_message_stanza
from gajim.common import app
from gajim.common import configpaths
@@ -40,22 +40,22 @@ from gajim.common.modules.base import BaseModule
from gajim.common.modules.util import event_node
from gajim.common.structs import OutgoingMessage
from openpgp.modules.util import ENCRYPTION_NAME
from openpgp.modules.util import NOT_ENCRYPTED_TAGS
from openpgp.modules.util import Key
from openpgp.modules.util import Trust
from openpgp.modules.util import DecryptionFailed
from openpgp.modules.util import prepare_stanza
from openpgp.modules.key_store import PGPContacts
from openpgp.backend.sql import Storage
from openpgp.modules.key_store import PGPContacts
from openpgp.modules.util import DecryptionFailed
from openpgp.modules.util import ENCRYPTION_NAME
from openpgp.modules.util import Key
from openpgp.modules.util import NOT_ENCRYPTED_TAGS
from openpgp.modules.util import prepare_stanza
from openpgp.modules.util import Trust
if sys.platform == 'win32':
if sys.platform == "win32":
from openpgp.backend.pygpg import PythonGnuPG as PGPBackend
else:
from openpgp.backend.gpgme import GPGME as PGPBackend
log = logging.getLogger('gajim.p.openpgp')
log = logging.getLogger("gajim.p.openpgp")
# Module name
@@ -65,24 +65,26 @@ zeroconf = False
class OpenPGP(BaseModule):
_nbxmpp_extends = 'OpenPGP'
_nbxmpp_extends = "OpenPGP"
_nbxmpp_methods = [
'set_keylist',
'request_keylist',
'set_public_key',
'request_public_key',
'set_secret_key',
'request_secret_key',
"set_keylist",
"request_keylist",
"set_public_key",
"request_public_key",
"set_secret_key",
"request_secret_key",
]
def __init__(self, client):
BaseModule.__init__(self, client)
self.handlers = [
StanzaHandler(name='message',
callback=self.decrypt_message,
ns=Namespace.OPENPGP,
priority=9),
StanzaHandler(
name="message",
callback=self.decrypt_message,
ns=Namespace.OPENPGP,
priority=9,
),
]
self._register_pubsub_handler(self._keylist_notification_received)
@@ -90,7 +92,7 @@ class OpenPGP(BaseModule):
self.own_jid = self._client.get_own_jid()
own_bare_jid = self.own_jid.bare
path = Path(configpaths.get('MY_DATA')) / 'openpgp' / own_bare_jid
path = Path(configpaths.get("MY_DATA")) / "openpgp" / own_bare_jid
if not path.exists():
path.mkdir(mode=0o700, parents=True)
@@ -98,7 +100,7 @@ class OpenPGP(BaseModule):
self._storage = Storage(path)
self._contacts = PGPContacts(self._pgp, self._storage)
self._fingerprint, self._date = self.get_own_key_details()
log.info('Own Fingerprint at start: %s', self._fingerprint)
log.info("Own Fingerprint at start: %s", self._fingerprint)
@property
def secret_key_available(self):
@@ -112,27 +114,22 @@ class OpenPGP(BaseModule):
self._pgp.generate_key()
def set_public_key(self):
log.info('%s => Publish public key', self._account)
log.info("%s => Publish public key", self._account)
key = self._pgp.export_key(self._fingerprint)
self._nbxmpp('OpenPGP').set_public_key(
key, self._fingerprint, self._date)
self._nbxmpp("OpenPGP").set_public_key(key, self._fingerprint, self._date)
def request_public_key(self, jid, fingerprint):
log.info('%s => Request public key %s - %s',
self._account, fingerprint, jid)
self._nbxmpp('OpenPGP').request_public_key(
jid,
fingerprint,
callback=self._public_key_received,
user_data=fingerprint)
log.info("%s => Request public key %s - %s", self._account, fingerprint, jid)
self._nbxmpp("OpenPGP").request_public_key(
jid, fingerprint, callback=self._public_key_received, user_data=fingerprint
)
def _public_key_received(self, task):
fingerprint = task.get_user_data()
try:
result = task.finish()
except (StanzaError, MalformedStanzaError) as error:
log.error('%s => Public Key not found: %s',
self._account, error)
log.error("%s => Public Key not found: %s", self._account, error)
return
imported_key = self._pgp.import_key(result.key, result.jid)
@@ -142,8 +139,8 @@ class OpenPGP(BaseModule):
def set_keylist(self, keylist=None):
if keylist is None:
keylist = [PGPKeyMetadata(None, self._fingerprint, self._date)]
log.info('%s => Publish keylist', self._account)
self._nbxmpp('OpenPGP').set_keylist(keylist)
log.info("%s => Publish keylist", self._account)
self._nbxmpp("OpenPGP").set_keylist(keylist)
@event_node(Namespace.OPENPGP_PK)
def _keylist_notification_received(self, _con, _stanza, properties):
@@ -157,46 +154,43 @@ class OpenPGP(BaseModule):
def request_keylist(self, jid=None):
if jid is None:
jid = self.own_jid
log.info('%s => Fetch keylist %s', self._account, jid)
log.info("%s => Fetch keylist %s", self._account, jid)
self._nbxmpp('OpenPGP').request_keylist(
jid,
callback=self._keylist_received,
user_data=jid)
self._nbxmpp("OpenPGP").request_keylist(
jid, callback=self._keylist_received, user_data=jid
)
def _keylist_received(self, task):
jid = task.get_user_data()
try:
keylist = task.finish()
except (StanzaError, MalformedStanzaError) as error:
log.error('%s => Keylist query failed: %s',
self._account, error)
log.error("%s => Keylist query failed: %s", self._account, error)
if self.own_jid.bare_match(jid) and self._fingerprint is not None:
self.set_keylist()
return
log.info('Keylist received from %s', jid)
log.info("Keylist received from %s", jid)
self._process_keylist(keylist, jid)
def _process_keylist(self, keylist, from_jid):
if not keylist:
log.warning('%s => Empty keylist received from %s',
self._account, from_jid)
log.warning("%s => Empty keylist received from %s", self._account, from_jid)
self._contacts.process_keylist(self.own_jid, keylist)
if self.own_jid.bare_match(from_jid) and self._fingerprint is not None:
self.set_keylist()
return
if self.own_jid.bare_match(from_jid):
log.info('Received own keylist')
log.info("Received own keylist")
for key in keylist:
log.info(key.fingerprint)
for key in keylist:
# Check if own fingerprint is published
if key.fingerprint == self._fingerprint:
log.info('Own key found in keys list')
log.info("Own key found in keys list")
return
log.info('Own key not published')
log.info("Own key not published")
if self._fingerprint is not None:
keylist.append(Key(self._fingerprint, self._date))
self.set_keylist(keylist)
@@ -228,31 +222,29 @@ class OpenPGP(BaseModule):
try:
payload, recipients, _timestamp = parse_signcrypt(signcrypt)
except StanzaMalformed as error:
log.warning('Decryption failed: %s', error)
log.warning("Decryption failed: %s", error)
log.warning(payload)
return
if not any(map(self.own_jid.bare_match, recipients)):
log.warning('to attr not valid')
log.warning("to attr not valid")
log.warning(signcrypt)
return
keys = self._contacts.get_keys(remote_jid)
fingerprints = [key.fingerprint for key in keys]
if fingerprint not in fingerprints:
log.warning('Invalid fingerprint on message: %s', fingerprint)
log.warning('Expected: %s', fingerprints)
log.warning("Invalid fingerprint on message: %s", fingerprint)
log.warning("Expected: %s", fingerprints)
return
log.info('Received OpenPGP message from: %s', properties.jid)
log.info("Received OpenPGP message from: %s", properties.jid)
prepare_stanza(stanza, payload)
trust = self._contacts.get_trust(remote_jid, fingerprint)
properties.encrypted = EncryptionData(
protocol=ENCRYPTION_NAME,
key=fingerprint,
trust=trust
protocol=ENCRYPTION_NAME, key=fingerprint, trust=trust
)
raise StanzaDecrypted
@@ -262,39 +254,38 @@ class OpenPGP(BaseModule):
keys = self._contacts.get_keys(remote_jid)
if not keys:
log.error('Droping stanza to %s, because we have no key', remote_jid)
log.error("Droping stanza to %s, because we have no key", remote_jid)
return
keys += self._contacts.get_keys(self.own_jid)
keys += [Key(self._fingerprint, None)]
payload = create_signcrypt_node(message.get_stanza(),
[remote_jid],
NOT_ENCRYPTED_TAGS)
payload = create_signcrypt_node(
message.get_stanza(), [remote_jid], NOT_ENCRYPTED_TAGS
)
encrypted_payload, error = self._pgp.encrypt(payload, keys)
if error:
log.error('Error: %s', error)
text = message.get_text(with_fallback=False) or ''
log.error("Error: %s", error)
text = message.get_text(with_fallback=False) or ""
app.ged.raise_event(
MessageNotSent(client=self._client,
jid=str(remote_jid),
message=text,
error=error,
time=time.time()))
MessageNotSent(
client=self._client,
jid=str(remote_jid),
message=text,
error=error,
time=time.time(),
)
)
return
create_message_stanza(
message.get_stanza(),
encrypted_payload,
bool(message.get_text())
message.get_stanza(), encrypted_payload, bool(message.get_text())
)
message.set_encryption(
EncryptionData(
protocol=ENCRYPTION_NAME,
key='Unknown',
trust=Trust.VERIFIED
protocol=ENCRYPTION_NAME, key="Unknown", trust=Trust.VERIFIED
)
)
@@ -302,12 +293,12 @@ class OpenPGP(BaseModule):
@staticmethod
def print_msg_to_log(stanza):
""" Prints a stanza in a fancy way to the log """
log.debug('-'*15)
stanzastr = '\n' + stanza.__str__(fancy=True)
"""Prints a stanza in a fancy way to the log"""
log.debug("-" * 15)
stanzastr = "\n" + stanza.__str__(fancy=True)
stanzastr = stanzastr[0:-1]
log.debug(stanzastr)
log.debug('-'*15)
log.debug("-" * 15)
def get_keys(self, jid=None, only_trusted=True):
if jid is None:
@@ -324,4 +315,4 @@ class OpenPGP(BaseModule):
def get_instance(*args, **kwargs):
return OpenPGP(*args, **kwargs), 'OpenPGP'
return OpenPGP(*args, **kwargs), "OpenPGP"