v1.0.9

v1.0.9

Author: SendSafely-GitHub

requirements.txt

@@ -1,3 +1,4 @@
 standard-imghdr~=3.13.0
 requests~=2.32.2
-PGPy~=0.6
+cryptography>=3.3.2
+pyasn1

sendsafely/Package.py

@@ -3,14 +3,14 @@
 import os
 import re
 
+from .pgpy import PGPMessage
 import requests
 import cryptography
 major, minor, patch = [int(x, 10) for x in cryptography.__version__.split('.')]
 if major < 41:
     from cryptography import CryptographyDeprecationWarning
 else:
     from cryptography.utils import CryptographyDeprecationWarning
-from pgpy import PGPMessage
 from sendsafely.Progress import Progress
 import warnings
 

sendsafely/SendSafely.py

@@ -3,15 +3,14 @@
 import warnings
 
 import requests
-import pgpy
 import cryptography
 major, minor, patch = [int(x, 10) for x in cryptography.__version__.split('.')]
 if major < 41:
     from cryptography import CryptographyDeprecationWarning
 else:
     from cryptography.utils import CryptographyDeprecationWarning
-from pgpy import PGPMessage
-from pgpy.constants import KeyFlags, HashAlgorithm, SymmetricKeyAlgorithm, CompressionAlgorithm, PubKeyAlgorithm
+from .pgpy import PGPMessage, PGPUID, PGPKey
+from .pgpy.constants import KeyFlags, HashAlgorithm, SymmetricKeyAlgorithm, CompressionAlgorithm, PubKeyAlgorithm
 from sendsafely.Package import Package
 from sendsafely.exceptions import GetPackagesException, GetUserInformationException, TrustedDeviceException, \
     DeletePackageException, GetPackageInformationFailedException, GetKeycodeFailedException
@@ -74,13 +73,13 @@ def generate_trusted_device_key_pair(self, description):
        :return: The response, including key pair
        """
         email = self.get_user_information()["email"]
-        key = pgpy.PGPKey.new(pgpy.constants.PubKeyAlgorithm.RSAEncryptOrSign, 2048)
-        uid = pgpy.PGPUID.new('Trusted Browser', email=email)
+        key = PGPKey.new(PubKeyAlgorithm.RSAEncryptOrSign, 2048)
+        uid = PGPUID.new('Trusted Browser', email=email)
         key.add_uid(uid=uid, usage={KeyFlags.Sign, KeyFlags.Certify},
                     hashes=[HashAlgorithm.SHA256],
                     ciphers=[SymmetricKeyAlgorithm.AES256],
                     compression=[CompressionAlgorithm.Uncompressed])
-        subkey = pgpy.PGPKey.new(PubKeyAlgorithm.RSAEncryptOrSign, 2048)
+        subkey = PGPKey.new(PubKeyAlgorithm.RSAEncryptOrSign, 2048)
         key.add_subkey(subkey, usage={KeyFlags.EncryptCommunications, KeyFlags.EncryptStorage})
         public_key = str(key.pubkey)
         endpoint = "/public-key"
@@ -140,7 +139,7 @@ def get_package_keycode(self, package_id, public_key_id=None, private_key=None):
             if keycode_json['response'] == 'FAIL':
                 raise GetKeycodeFailedException(details=str(keycode))
 
-            key_pair = pgpy.PGPKey.from_blob(str(private_key))[0]
+            key_pair = PGPKey.from_blob(str(private_key))[0]
             keycode_message = PGPMessage.from_blob(keycode)
             decrypted_keycode = key_pair.decrypt(keycode_message).message
             return {"keyCode": decrypted_keycode}

sendsafely/pgpy/__init__.py

@@ -0,0 +1,16 @@
+""" PGPy :: Pretty Good Privacy for Python
+"""
+
+from .pgp import PGPKey
+from .pgp import PGPKeyring
+from .pgp import PGPMessage
+from .pgp import PGPSignature
+from .pgp import PGPUID
+
+__all__ = ['constants',
+           'errors',
+           'PGPKey',
+           'PGPKeyring',
+           'PGPMessage',
+           'PGPSignature',
+           'PGPUID', ]

sendsafely/pgpy/_curves.py

@@ -0,0 +1,103 @@
+""" _curves.py
+specify some additional curves that OpenSSL provides but cryptography doesn't explicitly expose
+"""
+
+from cryptography import utils
+
+from cryptography.hazmat.primitives.asymmetric import ec
+
+from cryptography.hazmat.bindings.openssl.binding import Binding
+
+__all__ = tuple()
+
+# TODO: investigate defining additional curves using EC_GROUP_new_curve
+#       https://wiki.openssl.org/index.php/Elliptic_Curve_Cryptography#Defining_Curves
+
+
+def _openssl_get_supported_curves():
+    if hasattr(_openssl_get_supported_curves, '_curves'):
+        return _openssl_get_supported_curves._curves
+
+    # use cryptography's cffi bindings to get an array of curve names
+    b = Binding()
+    cn = b.lib.EC_get_builtin_curves(b.ffi.NULL, 0)
+    cs = b.ffi.new('EC_builtin_curve[]', cn)
+    b.lib.EC_get_builtin_curves(cs, cn)
+
+    # store the result so we don't have to do all of this every time
+    curves = { b.ffi.string(b.lib.OBJ_nid2sn(c.nid)).decode('utf-8') for c in cs }
+    # Ed25519 and X25519 are always present in cryptography>=2.6
+    # The python cryptography lib provides a different interface for these curves,
+    # so they are handled differently in the ECDHPriv/Pub and EdDSAPriv/Pub classes
+    curves |= {'X25519', 'ed25519'}
+    _openssl_get_supported_curves._curves = curves
+    return curves
+
+
+def use_legacy_cryptography_decorator():
+    """
+    The decorator utils.register_interface was removed in version 38.0.0. Keep using it
+    if the decorator exists, inherit from `ec.EllipticCurve` otherwise.
+    """
+    return hasattr(utils, "register_interface") and callable(utils.register_interface)
+
+
+if use_legacy_cryptography_decorator():
+    @utils.register_interface(ec.EllipticCurve)
+    class BrainpoolP256R1(object):
+        name = 'brainpoolP256r1'
+        key_size = 256
+
+
+    @utils.register_interface(ec.EllipticCurve)  # noqa: E303
+    class BrainpoolP384R1(object):
+        name = 'brainpoolP384r1'
+        key_size = 384
+
+
+    @utils.register_interface(ec.EllipticCurve)  # noqa: E303
+    class BrainpoolP512R1(object):
+        name = 'brainpoolP512r1'
+        key_size = 512
+
+
+    @utils.register_interface(ec.EllipticCurve)  # noqa: E303
+    class X25519(object):
+        name = 'X25519'
+        key_size = 256
+
+
+    @utils.register_interface(ec.EllipticCurve)  # noqa: E303
+    class Ed25519(object):
+        name = 'ed25519'
+        key_size = 256
+else:
+    class BrainpoolP256R1(ec.EllipticCurve):
+        name = 'brainpoolP256r1'
+        key_size = 256
+
+
+    class BrainpoolP384R1(ec.EllipticCurve):  # noqa: E303
+        name = 'brainpoolP384r1'
+        key_size = 384
+
+
+    class BrainpoolP512R1(ec.EllipticCurve):  # noqa: E303
+        name = 'brainpoolP512r1'
+        key_size = 512
+
+
+    class X25519(ec.EllipticCurve):  # noqa: E303
+        name = 'X25519'
+        key_size = 256
+
+
+    class Ed25519(ec.EllipticCurve):  # noqa: E303
+        name = 'ed25519'
+        key_size = 256
+
+
+# add these curves to the _CURVE_TYPES list
+for curve in [BrainpoolP256R1, BrainpoolP384R1, BrainpoolP512R1, X25519, Ed25519]:
+    if curve.name not in ec._CURVE_TYPES and curve.name in _openssl_get_supported_curves():
+        ec._CURVE_TYPES[curve.name] = curve