artemis_framework 0.1.2__tar.gz → 0.1.4__tar.gz

{artemis_framework-0.1.2 → artemis_framework-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: artemis_framework
-Version: 0.1.2
+Version: 0.1.4
 Summary: A package for doing great things!
 License: MIT
 License-File: LICENSE

artemis_framework-0.1.4/artemis_framework/asphodel/core/encrypt_decrypt.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from artemis_framework.asphodel.core.gpg_context import build_gpg, check_result
+
+
+def encrypt_to_recipients(
+    gpg: "gnupg.GPG",   # type: ignore
+    plaintext: str | bytes,
+    recipients: list[str],
+    *,
+    armor: bool = True,
+    sign: str | None = None,
+    passphrase: str | None = None,
+    always_trust: bool = True,
+    extra_args: list[str] | None = None
+) -> str | bytes | None:
+    result = gpg.encrypt(
+        plaintext,
+        recipients,
+        armor=armor,
+        sign=sign,
+        passphrase=passphrase,
+        always_trust=always_trust,
+        extra_args=extra_args or []
+    )
+
+    if not check_result(result,  label=f"encrypt_to_recipients({recipients})"):
+        return None
+
+    return result.data.decode("ascii") if armor else result.data
+
+
+def encrypt_symmetric(
+    gpg: "gnupg.GPG",   # type: ignore
+    plaintext: str | bytes,
+    passphrase: str,
+    *,
+    armor: bool = True,
+    cipher_algo: str = "AES256"
+) -> str | bytes | None:
+    result = gpg.encrypt(
+        plaintext,
+        recipients=None,
+        symmetric=True,
+        passphrase=passphrase,
+        armor=armor,
+        extra_args=["--cipher-algo", cipher_algo, "--no-symkey-cache"]
+    )
+
+    if not check_result(result, label="encrypt_symmetric"):
+        return None
+
+    return result.data.decode("ascii") if armor else result.data
+
+
+def decrypt_data(
+    gpg: "gnupg.GPG",   # type: ignore
+    ciphertext: str | bytes,
+    *,
+    passphrase: str | None = None,
+    always_trust: bool = True
+) -> bytes | None:
+    result = gpg.decrypt(
+        ciphertext,
+        passphrase=passphrase,
+        always_trust=always_trust
+    )
+
+    if not check_result(result, label="decrypt_data"):
+        return None
+
+    return result.data
+
+
+def encrypt_file(
+    gpg: "gnupg.GPG",   # type: ignore
+    input_path: Path | str,
+    recipients: list[str],
+    *,
+    output_path: Path | str | None = None,
+    armor: bool = True,
+    sign : str | None = None,
+    passphrase: str | None = None,
+    always_trust: bool = True
+) -> Path | None:
+    src = Path(input_path)
+    if not src.exists():
+        print(f"[ERR] encrypt_file: {src} not found.")
+        return None
+
+    dst = Path(output_path) if output_path else src.with_suffix(src.suffix + (".asc" if armor else ".gpg"))
+
+    with open(src, "rb") as file:
+        result = gpg.encrypt_file(
+            file,
+            recipients=recipients,
+            armor=armor,
+            sign=sign,
+            passphrase=passphrase,
+            always_trust=always_trust,
+            output=str(dst)
+        )
+
+    if not check_result(result, label=f"encrypt_file({src.name})"):
+        return None
+
+    print(f"    output: {dst}")
+    return dst
+
+
+def decrypt_file(
+    gpg: "gnupg.GPG",   # type: ignore
+    input_path: Path | str,
+    *,
+    output_path: Path | str | None = None,
+    passphrase: str | None = None,
+    always_trust: bool = True
+) -> Path | None:
+    src = Path(input_path)
+    if not src.exists():
+        print(f"[ERR] decrypt_file: {src} not found.")
+        return None
+
+    if output_path:
+        dst = Path(output_path)
+    else:
+        dst = src.with_suffix("")
+
+    with open(src, "rb") as file:
+        result = gpg.decrypt_file(
+            file,
+            passphrase=passphrase,
+            always_trust=always_trust,
+            output=str(dst)
+        )
+
+    if not check_result(result, label=f"decrypt_file({src.name})"):
+        return None
+
+    print(f"    output: {dst}")
+    return dst
+
+
+def print_decrypt_signature_info(result) -> None:
+    sig_id = getattr(result, "signature_id", None)
+    key_id = getattr(result, "key_id", None)
+    uid = getattr(result, "username", None)
+    trust = getattr(result, "trust_text", None)
+
+    if sig_id or key_id:
+        print("\n  [Signature embedded in ciphertext]")
+        print(f"  signer UID    : {uid or '<unknown>'}")
+        print(f"  key ID        : {key_id or '<unknown>'}")
+        print(f"  trust         : {trust or '<unknown>'}")
+    else:
+        print("\n  [No embedded signature detected]")
+        

artemis_framework-0.1.4/artemis_framework/asphodel/core/sign_verify.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from artemis_framework.asphodel.core.gpg_context import build_gpg, check_result
+
+
+@dataclass
+class VerificationResult:
+    valid: bool
+    fingerprint: str
+    key_id: str
+    username: str
+    status: str
+    timestamp: int | None
+    expire_timestamp: int | None
+    trust_level: str
+    stderr: str
+
+    def __str__(self) -> str:
+        lines = (
+            f"  valid           : {self.valid}",
+            f"  fingerprint     : {self.fingerprint}",
+            f"  key_id          : {self.key_id}",
+            f"  username        : {self.username}",
+            f"  status          : {self.status}",
+            f"  timestamp       : {self.timestamp}",
+            f"  trust_level     : {self.trust_level}",
+        )
+        return "\n".join(lines)
+
+    @classmethod
+    def from_gnupg(cls, result) -> "VerificationResult":
+        sigs = getattr(result, "sig_info", {})
+
+        if sigs:
+            fp, info = next(iter(sigs.items()))
+            key_id = info.get("keyid", "")
+            username = info.get("username", "")
+            status = info.get("status", "")
+            ts = info.get("timestamp")
+            exp_ts = info.get("expire_timestamp")
+            trust = info.get("trust_level", "")
+        else:
+            fp = getattr(result, "fingerprint", "") or ""
+            key_id = getattr(result, "key_id", "") or ""
+            username = getattr(result, "username", "") or ""
+            status = getattr(result, "status", "") or ""
+            ts = getattr(result, "timestamp", None)
+            exp_ts = None
+            trust = getattr(result, "trust_level", "") or ""
+        valid = bool(getattr(result, "valid", False))
+
+        return cls(
+            valid=valid,
+            fingerprint=fp,
+            key_id=key_id,
+            username=username,
+            status=status,
+            timestamp=int(ts) if ts else None,
+            expire_timestamp=int(exp_ts) if exp_ts else None,
+            trust_level=trust,
+            stderr=getattr(result, "stderr", "") or ""
+        )
+
+
+def clearsign(
+    gpg,
+    message: str | bytes,
+    signing_fingerprint: str,
+    *,
+    passphrase: str | None = None,
+    detach: bool = False
+) -> str | None:
+    result = gpg.sign(
+        message,
+        keyid=signing_fingerprint,
+        passphrase=passphrase,
+        clearsign=True
+    )
+
+    if not result:
+        print(f"[ERR] clearsign failed for <{signing_fingerprint[:16]}…>")
+        print(f"      stderr: {result.stderr}")
+        return None
+
+    print(f"[OK]  clearsign({signing_fingerprint[:16]}…)")
+    return str(result)
+
+
+def sign_detached(
+    gpg,
+    message: str | bytes,
+    signing_fingerprint: str,
+    *,
+    passphrase: str | None = None,
+    armor: bool = True
+) -> str | bytes | None:
+    result = gpg.sign(
+        message,
+        keyid=signing_fingerprint,
+        passphrase=passphrase,
+        detach=True,
+        clearsign=False
+    )
+
+    if not result:
+        print(f"[ERR] sign_detached failed for <{signing_fingerprint[:16]}…>")
+        print(f"      stderr: {result.stderr}")
+        return None
+
+    sig_data = str(result)
+    print(f"[OK]  sign_detached({signing_fingerprint[:16]}…, armor={armor})")
+
+    if armor:
+        return sig_data
+
+    return sig_data
+
+
+def sign_inline(
+    gpg,
+    message: str | bytes,
+    signing_fingerprint: str,
+    *,
+    passphrase: str | None = None
+) -> bytes | None:
+    result = gpg.sign(
+        message,
+        keyid=signing_fingerprint,
+        passphrase=passphrase,
+        detach=False,
+        clearsign=False,
+        binary=True
+    )
+
+    if not result:
+        print(f"[ERR] sign_inline failed for <{signing_fingerprint[:16]}…>")
+        return None
+
+    print(f"[OK]  sign_inline({signing_fingerprint[:16]}…)")
+    return result.data
+
+
+def sign_file_detached(
+    gpg,
+    file_path: Path | str,
+    signing_fingerprint: str,
+    *,
+    passphrase: str | None = None,
+    output_path: Path | str | None = None,
+    armor: bool = True
+) -> Path | None:
+    src = Path(file_path)
+    if not src.exists():
+        print(f"[ERR] sign_file_detached: {src} not found.")
+        return None
+
+    ext = ".asc" if armor else ".sig"
+    dst = Path(output_path) if output_path else src.with_suffix(src.sufix + ext)
+
+    with open(src, "rb") as file:
+        result = gpg.sign_file(
+            file,
+            keyid=signing_fingerprint,
+            passphrase=passphrase,
+            detach=True,
+            clearsign=False,
+            output=str(dst)
+        )
+
+    if not result:
+        print(f"[ERR] sign_file_detached({src.name}): {result.stderr}")
+        return None
+
+    print(f"[OK]  sign_file_detached » {dst}")
+    return dst
+
+
+def verify_clearsign(
+    gpg,
+    signed_message: str,
+    *,
+    always_trust: bool = True
+) -> VerificationResult:
+    result = gpg.verify(signed_message)
+    vr = VerificationResult.from_gnupg(result)
+    label = "verify_clearsign"
+    if vr.valid:
+        print(f"[OK]  {label}")
+    else:
+        print(f"[ERR] {label}")
+    print(vr)
+    return vr
+
+
+def verify_detached(
+    gpg,
+    message: str | bytes,
+    signature: str | bytes
+) -> VerificationResult:
+    import tempfile, os
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".asc") as tmp:
+        if isinstance(signature, str):
+            tmp.write(signature.encode())
+        else:
+            tmp.write(signature)
+        tmp_path = tmp.name
+
+    try:
+        if isinstance(message, str):
+            message = message.encode()
+
+        result = gpg.verify_data(tmp_path, message)
+    finally:
+        os.unlink(tmp_path)
+
+    vr = VerificationResult.from_gnupg(result)
+    label = "verify_detached"
+    if vr.valid:
+        print(f"[OK]  {label}")
+    else:
+        print(f"[ERR] {label}")
+    print(vr)
+    return vr
+
+
+def verify_detached_file(
+    gpg,
+    file_path: Path | str,
+    sig_path: Path | str
+) -> VerificationResult:
+    src = Path(file_path)
+    sig = Path(sig_path)
+
+    message_bytes = src.read_bytes()
+    sig_bytes = sig.read_bytes()
+
+    return verify_detached(gpg, message_bytes, sig_bytes)
+
+
+def verify_inline(gpg, signed_data: bytes) -> VerificationResult:
+    result = gpg.decrypt(signed_data, always_trust=True)
+
+    vr = VerificationResult.from_gnupg(result)
+    label = "verify_inline"
+    if vr.valid:
+        print(f"[OK]  {label}")
+    else:
+        print(f"[WARN] {label} - no valid signature found (or unsigned data)")
+    print(vr)
+    return vr
+
+

{artemis_framework-0.1.2 → artemis_framework-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "artemis_framework"
-version = "0.1.2"
+version = "0.1.4"
 description = "A package for doing great things!"
 authors = ["Dylan Garrett"]
 license = "MIT"