envelope 2.3.0__tar.gz → 2.4.0__tar.gz

envelope-2.4.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: envelope
+Version: 2.4.0
+Summary: Insert a message and attachments and send e-mail / sign / encrypt contents by a single line.
+License: LGPL-3.0-or-later
+License-File: LICENSE
+Author: Edvard Rejthar
+Author-email: edvard.rejthar@nic.cz
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: smime
+Requires-Dist: cryptography (>=43) ; extra == "smime"
+Requires-Dist: py3-validate-email
+Requires-Dist: python-gnupg (>=0.5)
+Requires-Dist: python-magic
+Project-URL: Homepage, https://github.com/CZ-NIC/envelope
+Description-Content-Type: text/markdown
+
+# Envelope
+
+[![Build Status](https://github.com/CZ-NIC/envelope/actions/workflows/run-unittest.yml/badge.svg)](https://github.com/CZ-NIC/envelope/actions) [![Downloads](https://static.pepy.tech/badge/envelope)](https://pepy.tech/project/envelope)
+
+A thin, fluent layer over [python-gnupg](https://bitbucket.org/vinay.sajip/python-gnupg/src), [cryptography](https://github.com/pyca/cryptography), [M2Crypto](https://m2crypto.readthedocs.io/), [smtplib](https://docs.python.org/3/library/smtplib.html), [magic](https://pypi.org/project/python-magic/) and [email](https://docs.python.org/3/library/email.html?highlight=email#module-email) — their common use cases merged into a single object. Tired of forgetting how to sign a message correctly? You do not need to know everything about GPG or S/MIME, you do not have to bother with importing keys, you do not have to hassle with reconnecting to an SMTP server, and you do not have to study what every header means just to let your users unsubscribe via a URL.
+You insert a message, attachments and inline images and get back signed and/or encrypted output — written to a file or sent straight to your recipients' e-mail.
+Just a single line of code, as the examples below show.
+
+```python3
+Envelope("my message")
+    .subject("hello world")
+    .to("example@example.com")
+    .attach(file_contents, name="attached-file.txt")
+    .smtp("localhost", 587, "user", "pass", "starttls")
+    .signature()
+    .send()
+```
+
+```python3
+# Inline image
+Envelope("My inline image: <img src='cid:image.jpg' />")
+    .attach(path="image.jpg", inline=True)
+
+# Load a message and read its attachments
+Envelope.load(path="message.eml").attachments()
+# in bash: envelope --load message.eml --attachments
+```
+
+## Documentation
+
+- [Installation](https://cz-nic.github.io/envelope/installation/) — PyPI/GitHub install, GPG/S-MIME prerequisites, bash completion.
+- [Usage](https://cz-nic.github.io/envelope/usage/) — the CLI, the fluent interface and the one-liner module call.
+- Reference — every setter, in all three interfaces:
+    * [Overview](https://cz-nic.github.io/envelope/reference/overview/) — notation used below, "any attainable contents".
+    * [Input / Output](https://cz-nic.github.io/envelope/reference/input-output/) — message, output.
+    * [Recipients](https://cz-nic.github.io/envelope/reference/recipients/) — from, to, cc, bcc, reply-to, from_addr.
+    * [Sending](https://cz-nic.github.io/envelope/reference/sending/) — send, subject, date, smtp, attachments, mime, headers.
+    * [Ciphering](https://cz-nic.github.io/envelope/reference/ciphering/) — choosing GPG/S-MIME, signing, encrypting.
+    * [Supportive](https://cz-nic.github.io/envelope/reference/supportive/) — recipients(), copy(), preview, check, load, Address.
+    * [Experimental](https://cz-nic.github.io/envelope/reference/experimental/) — `_report()`, `_check_auth()`.
+    * [Envelope object](https://cz-nic.github.io/envelope/reference/envelope-object/) — converting to str/bool, object equality.
+- [Examples](https://cz-nic.github.io/envelope/examples/) — signing/encrypting, sending, attachments, inline images, a complex example.
+- [Related affairs](https://cz-nic.github.io/envelope/related-affairs/) — configuring an SMTP server, GPG, S/MIME, and SPF/DKIM/DMARC.
+- [Changelog](https://cz-nic.github.io/envelope/changelog/)
+

envelope-2.4.0/README.md

@@ -0,0 +1,44 @@
+# Envelope
+
+[![Build Status](https://github.com/CZ-NIC/envelope/actions/workflows/run-unittest.yml/badge.svg)](https://github.com/CZ-NIC/envelope/actions) [![Downloads](https://static.pepy.tech/badge/envelope)](https://pepy.tech/project/envelope)
+
+A thin, fluent layer over [python-gnupg](https://bitbucket.org/vinay.sajip/python-gnupg/src), [cryptography](https://github.com/pyca/cryptography), [M2Crypto](https://m2crypto.readthedocs.io/), [smtplib](https://docs.python.org/3/library/smtplib.html), [magic](https://pypi.org/project/python-magic/) and [email](https://docs.python.org/3/library/email.html?highlight=email#module-email) — their common use cases merged into a single object. Tired of forgetting how to sign a message correctly? You do not need to know everything about GPG or S/MIME, you do not have to bother with importing keys, you do not have to hassle with reconnecting to an SMTP server, and you do not have to study what every header means just to let your users unsubscribe via a URL.
+You insert a message, attachments and inline images and get back signed and/or encrypted output — written to a file or sent straight to your recipients' e-mail.
+Just a single line of code, as the examples below show.
+
+```python3
+Envelope("my message")
+    .subject("hello world")
+    .to("example@example.com")
+    .attach(file_contents, name="attached-file.txt")
+    .smtp("localhost", 587, "user", "pass", "starttls")
+    .signature()
+    .send()
+```
+
+```python3
+# Inline image
+Envelope("My inline image: <img src='cid:image.jpg' />")
+    .attach(path="image.jpg", inline=True)
+
+# Load a message and read its attachments
+Envelope.load(path="message.eml").attachments()
+# in bash: envelope --load message.eml --attachments
+```
+
+## Documentation
+
+- [Installation](https://cz-nic.github.io/envelope/installation/) — PyPI/GitHub install, GPG/S-MIME prerequisites, bash completion.
+- [Usage](https://cz-nic.github.io/envelope/usage/) — the CLI, the fluent interface and the one-liner module call.
+- Reference — every setter, in all three interfaces:
+    * [Overview](https://cz-nic.github.io/envelope/reference/overview/) — notation used below, "any attainable contents".
+    * [Input / Output](https://cz-nic.github.io/envelope/reference/input-output/) — message, output.
+    * [Recipients](https://cz-nic.github.io/envelope/reference/recipients/) — from, to, cc, bcc, reply-to, from_addr.
+    * [Sending](https://cz-nic.github.io/envelope/reference/sending/) — send, subject, date, smtp, attachments, mime, headers.
+    * [Ciphering](https://cz-nic.github.io/envelope/reference/ciphering/) — choosing GPG/S-MIME, signing, encrypting.
+    * [Supportive](https://cz-nic.github.io/envelope/reference/supportive/) — recipients(), copy(), preview, check, load, Address.
+    * [Experimental](https://cz-nic.github.io/envelope/reference/experimental/) — `_report()`, `_check_auth()`.
+    * [Envelope object](https://cz-nic.github.io/envelope/reference/envelope-object/) — converting to str/bool, object equality.
+- [Examples](https://cz-nic.github.io/envelope/examples/) — signing/encrypting, sending, attachments, inline images, a complex example.
+- [Related affairs](https://cz-nic.github.io/envelope/related-affairs/) — configuring an SMTP server, GPG, S/MIME, and SPF/DKIM/DMARC.
+- [Changelog](https://cz-nic.github.io/envelope/changelog/)

{envelope-2.3.0 → envelope-2.4.0}/envelope/__main__.py

@@ -1,13 +1,12 @@
 import argparse
+import json
 import select
 import sys
 from pathlib import Path
 
-from jsonpickle import decode
-
 from .envelope import Envelope, __doc__ as doc
 from .attachment import Attachment
-
+from .constants import SENDMAIL_PATH
 
 class SmartFormatter(argparse.RawDescriptionHelpFormatter):
 
@@ -141,6 +140,9 @@ def main():
                                  " Security may be explicitly set to 'starttls', 'tls'"
                                  " or automatically determined by port.",
                             nargs="*", action=BlankTrue, metavar=("HOST", "PORT"))
+    group_send.add_argument('--sendmail', help="Path to sendmail binary. Disables SMTP."
+                                          f" Leave blank for default {SENDMAIL_PATH}.", nargs="?", action=BlankTrue,
+                                          metavar="PATH")
     group_send.add_argument('--send', help="Send e-mail. Blank to send now.", nargs="?", action=BlankTrue)
 
     group_supp = parser.add_argument_group("Supportive")
@@ -230,7 +232,20 @@ def main():
 
     # smtp can be a dict
     if args["smtp"] and args["smtp"][0].startswith("{"):
-        args["smtp"] = decode(" ".join(args["smtp"]))
+        smtp_allowed_keys = {"host", "port", "user", "password", "security", "timeout",
+                             "attempts", "delay", "local_hostname"}
+        try:
+            smtp_dict = json.loads(" ".join(args["smtp"]))
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Invalid JSON in --smtp: {e}")
+        if not isinstance(smtp_dict, dict):
+            raise RuntimeError("--smtp JSON must be an object/dict.")
+        unknown_keys = smtp_dict.keys() - smtp_allowed_keys
+        if unknown_keys:
+            raise RuntimeError(f"Unknown --smtp key(s): {', '.join(unknown_keys)}")
+        args["smtp"] = smtp_dict
+    elif args["smtp"] and args["smtp"].lower() in ["0", "false", "no"]:
+        args["smtp"] = False
 
     # send = False turns on debugging
     if args["send"] and type(args["send"]) is not bool:

{envelope-2.3.0 → envelope-2.4.0}/envelope/constants.py

@@ -19,4 +19,5 @@ SIMULATION = "simulation"
 # We cannot set as constant whole os.environ dict as it might be changed in the tests.py (settings GNUPG_HOME).
 SAFE_LOCALE = "C" if (sys.version_info.major, sys.version_info.minor) > (3, 6) else "C.UTF-8"
 
-ISSUE_LINK = "https://github.com/CZ-NIC/envelope/issues/new"
+ISSUE_LINK = "https://github.com/CZ-NIC/envelope/issues/new"
+SENDMAIL_PATH = "/usr/sbin/sendmail"

{envelope-2.3.0 → envelope-2.4.0}/envelope/envelope.py

@@ -27,11 +27,12 @@ from typing import Literal, Union, Optional, Any
 from ._auth import AuthResult
 from .address import Address, _getaddresses
 from .attachment import Attachment
-from .constants import ISSUE_LINK, smime_import_error, gnupg, CRLF, AUTO, PLAIN, HTML, SIMULATION, SAFE_LOCALE
+from .constants import ISSUE_LINK, smime_import_error, gnupg, CRLF, AUTO, PLAIN, HTML, SIMULATION, SAFE_LOCALE, SENDMAIL_PATH
 from .message import _Message
 from .parser import Parser
 from .smtp_handler import SMTPHandler
-from .utils import AutoSubmittedHeader, Fetched, is_gpg_importable_key, assure_list, assure_fetched, get_mimetype
+from .utils import AutoSubmittedHeader, Fetched, is_gpg_importable_key, assure_list, assure_fetched, get_mimetype, \
+    is_safe_argv_value
 
 
 __doc__ = """Quick layer over python-gnupg, M2Crypto, smtplib, magic and email handling packages.
@@ -268,7 +269,7 @@ class Envelope:
                  gpg=None, smime=None,
                  encrypt=None, sign=None, passphrase=None, attach_key=None, cert=None, subject_encrypted=None,
                  sender=None, cc=None, bcc=None, reply_to=None, mime=None, attachments=None,
-                 smtp=None, output=None, send=None):
+                 smtp=None, sendmail=None, output=None, send=None):
         """
         :rtype: object If output not set, return output bytes, else True/False if output file was correctly written to.
 
@@ -302,6 +303,10 @@ class Envelope:
         :param mime: Set contents mime subtype: "html" (default) or "plain" for plain text
         :param smtp: tuple or dict of these optional parameters: host, port, username, password, security ("tlsstart").
             Or link to existing INI file with the SMTP section.
+            Or False to not use SMTP.
+        :param sendmail: True or path to ubiquitious sendmail binary.
+            Otherwise the standard "/usr/sbin/sendmail" is used.
+            Sendmail is only used if this method OR smtp(False) is called
         :param send: True for sending the mail. False will just print the output.
         :param cc: E-mail or more in an iterable.
         :param bcc: E-mail or more in an iterable.
@@ -336,7 +341,6 @@ class Envelope:
         self._reply_to: list[Address] = []
         self._subject: Union[str, None] = None
         self._subject_encrypted: Union[str, bool] = True
-        self._smtp = None
         self._attachments: list[Attachment] = []
         self._mime = AUTO
         self._nl2br = AUTO
@@ -349,7 +353,8 @@ class Envelope:
         self._result: list[Union[str, EmailMessage, Message]] = []  # text output for str() conversion
         self._result_cache: Optional[str] = None
         self._result_cache_hash: Optional[int] = None
-        self._smtp = SMTPHandler()
+        self._smtp: Union[SMTPHandler, bool] = SMTPHandler()
+        self._sendmail: Union[str, bool, None, Path] = False
         self.auto_submitted = AutoSubmittedHeader(self)  # allows fluent interface to set header
 
         self._multipart_report_message: Optional[Message] = None
@@ -729,7 +734,7 @@ class Envelope:
         Obtain SMTP server connection.
         Note that you may safely call this in a loop,
             envelope will remember the settings and connect only once (without reconnecting every iteration).
-        :param host: hostname, smtplib.SMTP, INI file path, or a list or dict with the parameters (see README.md)
+        :param host: hostname, smtplib.SMTP, INI file path, False, or a list or dict with the parameters (see README.md)
         :param port:
         :param user:
         :param password:
@@ -771,11 +776,24 @@ class Envelope:
             self._smtp = SMTPHandler(*host)
         elif isinstance(host, smtplib.SMTP):
             self._smtp = SMTPHandler(host)
+        elif host == False:
+            self._smtp = False
+            self._sendmail = True
         else:
             self._smtp = SMTPHandler(host, port, user, password, security, timeout=timeout, attempts=attempts,
                                      delay=delay, local_hostname=local_hostname)
         return self
 
+    def sendmail(self, sendmail=True):
+        """
+        :param sendmail: String for Sendmail binary or True.
+        Disables SMTP when enabled.
+        """
+        self._sendmail = sendmail
+        if bool(self._sendmail):
+            self._smtp = False
+        return self
+
     def attach(self, attachment=None, mimetype=None, name=None, inline=None, *, path=None):
         """
 
@@ -1144,15 +1162,8 @@ class Envelope:
 
         if send and send != SIMULATION:
             recipients = list(map(str, set(self._to + self._cc + self._bcc)))
-            with mock.patch.object(Generator, '_handle_multipart_signed', Generator._handle_multipart):
-                # https://github.com/python/cpython/issues/99533 and #19
-                failures = self._smtp.send_message(email,
-                                                   from_addr=self._from_addr,
-                                                   to_addrs=recipients)
-            if failures:
-                logger.warning(f"Unable to send to all recipients: {repr(failures)}.")
-            elif failures is False:
-                # TODO add here and test, logger.warning(f"Sending {recipients}, Message-ID: {email["Message-ID"]}")
+            success = self._deliver_now(email, recipients)
+            if not success:
                 return False
         else:
             if send != SIMULATION:
@@ -1167,6 +1178,68 @@ class Envelope:
 
         return email
 
+    def _deliver_now(self, email, recipients):
+        # _smtp XOR _sendmail
+        if (_smtp := bool(self._smtp)) == (_sendmail := bool(self._sendmail)):
+            logger.error(f"Need either SMTP (is {('off', 'on')[_smtp]}) or local delivery/sendmail (is {('off', 'on')[_sendmail]}) to send")
+            return False
+        if self._smtp:
+            success_or_failures = self._deliver_smtp(email, self._from_addr, recipients)
+        elif self._sendmail:
+            success_or_failures = self._deliver_sendmail(email, self._from_addr or self._from, recipients)
+        else:
+            assert False, "Should not reach, either SMTP or Sendmail should work"
+
+        if success_or_failures:
+            logger.warning(f"Unable to send to all recipients: {repr(success_or_failures)}.")
+        # elif success_or_failures is False:
+        #     # TODO add here and test, logger.warning(f"Sending {recipients}, Message-ID: {email["Message-ID"]}")
+        #     return False
+        return success_or_failures
+
+    def _deliver_smtp(self, email, from_addr, recipients):
+        """
+        Use configured SMTP server to deliver email.
+        :param email: String contents of whole email to send
+        :param from_addr: Email address of sender
+        :param recipients: List of recipient email addresses
+        :returns: List of recipients to whom delivery failed.
+            Or False for an unspecified error condition
+        :rtype: list or False
+        """
+        if not isinstance(self._smtp, SMTPHandler):
+            self._smtp = SMTPHandler()
+        with mock.patch.object(Generator, '_handle_multipart_signed', Generator._handle_multipart):
+            # https://github.com/python/cpython/issues/99533 and #19
+            return self._smtp.send_message(email,
+                                           from_addr=self._from_addr,
+                                           to_addrs=recipients)
+
+    def _deliver_sendmail(self, email, from_addr, to_addrs):
+        """
+        Use a  local MTA with sendmail interface to send mail via queue"
+
+        :param email: String contents of whole email to send
+        :param from_addr: Email address of sender
+        :param recipients: (unused, for signature compatibility with _deliver_smtp,
+            Originally: List of recipient email addresses)
+        :returns: Empty list on success or False for an unspecified error condition
+            (For return compatibilty with _deliver_smtp)
+        :rtype: list or False
+        """
+        self._sendmail = SENDMAIL_PATH if self._sendmail == True  else str(self._sendmail)
+        _unused = to_addrs
+        from_addr = str(from_addr)
+        if not is_safe_argv_value(from_addr):
+            logger.error(f"Refusing to invoke sendmail with a suspicious From address: {from_addr!r}")
+            return False
+        args = [self._sendmail, "-t", "-oi", "-f", from_addr]
+        try:
+            subprocess.run(args, input=str(email), text=True, check=True)
+            return []
+        except subprocess.CalledProcessError:
+            return False
+
     def _param_hash(self):
         """ Check if headers changed from last _start call."""
         return (hash(frozenset(self._headers.items())) + hash("".join(self.recipients()))
@@ -1697,6 +1770,9 @@ class Envelope:
                     if type(query_or_list) is not list:
                         query_or_list = [query_or_list]
                     for query in query_or_list:
+                        if not is_safe_argv_value(query):
+                            logger.warning(f"Refusing to run dig with a suspicious query: {query!r}")
+                            return []
                         try:
                             text = subprocess.check_output(["dig", "-t", rr, query],
                                                            env=dict(environ, LC_ALL=SAFE_LOCALE)).decode("utf-8")

{envelope-2.3.0 → envelope-2.4.0}/envelope/parser.py

@@ -11,6 +11,8 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+MAX_PARSE_DEPTH = 20
+
 
 class Parser:
 
@@ -20,7 +22,9 @@ class Parser:
         self.cert = cert
         self.gnupg_home = gnupg_home
 
-    def parse(self, o: Message, add_headers=False):
+    def parse(self, o: Message, add_headers=False, depth=0):
+        if depth > MAX_PARSE_DEPTH:
+            raise ValueError(f"MIME structure nested too deeply (> {MAX_PARSE_DEPTH} levels)")
         if add_headers:
             for k, val in o.items():
                 # We skip "Content-Type" and "Content-Transfer-Encoding" since we decode text payload before importing.
@@ -45,12 +49,12 @@ class Parser:
         if o.is_multipart():
             payload: List[Message] = o.get_payload()
             if subtype == "alternative":
-                [self.parse(x) for x in payload]
+                [self.parse(x, depth=depth + 1) for x in payload]
             elif subtype in ("related", "mixed", "report"):
                 for p in payload:
                     if p.get_content_maintype() in ["text", "multipart"] \
                             and p.get_content_disposition() != "attachment":
-                        self.parse(p)
+                        self.parse(p, depth=depth + 1)
                     elif subtype == "report" and p.get_content_maintype() == "message":
                         if p.get_content_type() != FEEDBACK_REPORT:  # only XARF implemented
                             raise ValueError(f"Parsing {maintype}/{subtype} / {p.get_content_type()} not implemented.")
@@ -69,13 +73,14 @@ class Parser:
                     if p.get_content_type() == o.get_param("protocol"):  # ex: application/x-pkcs7-signature
                         continue  # XX we might verify signature
                     else:
-                        self.parse(p)
+                        self.parse(p, depth=depth + 1)
             elif subtype == "encrypted":
                 for p in payload:
                     if p.get_content_type() == o.get_param("protocol"):  # ex: application/pgp-encrypted
                         continue
                     elif p.get_content_type() == "application/octet-stream":
-                        self.parse(message_from_string(self.gpg_decrypt(p.get_payload(decode=True))), add_headers=True)
+                        self.parse(message_from_string(self.gpg_decrypt(p.get_payload(decode=True))),
+                                  add_headers=True, depth=depth + 1)
                     else:
                         raise ValueError(f"Cannot decrypt.")
             else:
@@ -96,7 +101,7 @@ class Parser:
             else:
                 raise ValueError(f"Unknown subtype: {subtype}")
         elif maintype == "application" and subtype == "x-pkcs7-mime":  # decrypting S/MIME
-            self.parse(message_from_bytes(self.smime_decrypt(o.as_bytes())), add_headers=True)
+            self.parse(message_from_bytes(self.smime_decrypt(o.as_bytes())), add_headers=True, depth=depth + 1)
         else:
             raise ValueError(f"Unknown maintype: {maintype}")
         return self.e

{envelope-2.3.0 → envelope-2.4.0}/envelope/smtp_handler.py

@@ -80,7 +80,8 @@ class SMTPHandler:
                 return smtp.send_message(email, from_addr=from_addr, to_addrs=to_addrs)
             except (timeout_exc, SMTPException) as e:
                 # this connection is gone, reconnect next time
-                del self._instances[self.key]
+                if self.key in self._instances:
+                    del self._instances[self.key]
                 if isinstance(e, SMTPAuthenticationError):
                     logger.warning(
                         f"SMTP authentication error, will not re-try. {e}")

{envelope-2.3.0 → envelope-2.4.0}/envelope/utils.py

@@ -1,5 +1,5 @@
 import logging
-from io import TextIOBase, BufferedIOBase
+from io import IOBase
 from pathlib import Path
 from typing import TYPE_CHECKING, Iterable
 
@@ -65,6 +65,16 @@ def get_mimetype(data: bytes = None, path: Path = None):
             return magic.detect_from_filename(str(path)).mime_type
 
 
+def is_safe_argv_value(s: str) -> bool:
+    """ Check a string is safe to pass as a single subprocess argv value derived from
+    untrusted (e.g. parsed e-mail) content: not empty, does not start with "-" (which some
+    CLI parsers could otherwise mistake for a new option) and contains no whitespace or
+    control characters. """
+    if not s or s[0] == "-":
+        return False
+    return all(c.isprintable() and not c.isspace() for c in s)
+
+
 def assure_list(v):
     """ Accepts object and returns list.
     If object is tuple, generator, set, frozenset, it's converted to a list.
@@ -76,7 +86,7 @@ def assure_list(v):
     """
     if v is None:
         return []
-    if isinstance(v, Iterable) and not isinstance(v, (TextIOBase, BufferedIOBase, str, bytes)):
+    if isinstance(v, Iterable) and not isinstance(v, (IOBase, str, bytes)):
         return list(v)
     return [v]
 
@@ -96,7 +106,7 @@ def assure_fetched(message, retyped=None) -> Fetched:
         return None
     elif isinstance(message, Path):
         message = message.read_bytes()
-    elif isinstance(message, (TextIOBase, BufferedIOBase)):
+    elif isinstance(message, IOBase):
         message = message.read()
     elif not isinstance(message, (str, bytes, bool)):
         raise ValueError(

{envelope-2.3.0 → envelope-2.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "envelope"
-version = "2.3.0"
+version = "2.4.0"
 description = "Insert a message and attachments and send e-mail / sign / encrypt contents by a single line."
 authors = ["Edvard Rejthar <edvard.rejthar@nic.cz>"]
 license = "LGPL-3.0-or-later"
@@ -14,13 +14,13 @@ classifiers = ["Programming Language :: Python :: 3"]
 
 [tool.poetry.dependencies]
 python = ">=3.10"
-jsonpickle = "*"
 python-magic = "*"
 python-gnupg = ">=0.5"
 py3-validate-email = "*"
+cryptography = { version = ">=43", optional = true }
 
-[tool.poetry.project.optional-dependencies]
-smime = ["cryptography>=43"]
+[tool.poetry.extras]
+smime = ["cryptography"]
 
 [tool.poetry.scripts]
 envelope = "envelope.__main__:main"