ipasign 1.0__py3-none-any.whl

ipasign/cms.py

@@ -0,0 +1,164 @@
+"""CMS / PKCS#7 signature generation.
+
+Apple seals a code signature with a detached CMS ``SignedData`` whose content is
+the CodeDirectory. The structure carries a handful of signed attributes, three of
+them standard and two Apple specific, and one detail decides whether the result
+verifies at all: the RSA signature is computed over the signed attributes
+encoded as a ``SET OF`` (tag ``0x31``), not over the ``[0]`` implicit form the
+SignerInfo carries them in. RFC 5652 section 5.4 signs the SET value; signing the
+implicit form produces a blob that parses cleanly and that ``codesign`` rejects
+with "code or signature have been modified".
+"""
+
+from __future__ import annotations
+
+import datetime
+import hashlib
+from dataclasses import dataclass
+
+from asn1crypto import algos, cms, core, x509 as asn1x509
+from cryptography import x509
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import padding
+
+from .credentials import Identity
+from .errors import BlobError
+
+OID_APPLE_CDHASHES_PLIST = "1.2.840.113635.100.9.1"
+OID_APPLE_CDHASHES = "1.2.840.113635.100.9.2"
+
+# Content bytes of OID 2.16.840.1.101.3.4.2.1 (sha256). The wrapping SEQUENCE
+# carries no parameters: adding a NULL there changes the bytes and breaks
+# parity with Apple's own output.
+_SHA256_OID_CONTENT = bytes.fromhex("608648016503040201")
+
+
+def _der_length(length: int) -> bytes:
+    if length < 0x80:
+        return bytes([length])
+    raw = length.to_bytes((length.bit_length() + 7) // 8, "big")
+    return bytes([0x80 | len(raw)]) + raw
+
+
+def _der_tlv(tag: int, body: bytes) -> bytes:
+    return bytes([tag]) + _der_length(len(body)) + body
+
+
+def _apple_cdhash_attribute(digest: bytes) -> bytes:
+    """``SEQUENCE { OID sha256, OCTET STRING <digest> }`` for attribute 9.2."""
+    inner = _der_tlv(0x06, _SHA256_OID_CONTENT)
+    return _der_tlv(0x30, inner + _der_tlv(0x04, digest))
+
+
+def _asn1_certificate(cert: x509.Certificate) -> asn1x509.Certificate:
+    return asn1x509.Certificate.load(cert.public_bytes(serialization.Encoding.DER))
+
+
+@dataclass(slots=True)
+class CmsParts:
+    """The inputs the CMS builder needs, already hashed by the caller."""
+
+    code_directory: bytes
+    cdhashes_plist: bytes
+    apple_hash: bytes
+    signing_time: datetime.datetime | None = None
+
+
+def build_cms(identity: Identity, parts: CmsParts) -> bytes:
+    """Build the detached CMS ``SignedData`` for a signed CodeDirectory."""
+    code_directory = parts.code_directory
+    if not code_directory:
+        raise BlobError("cannot sign an empty CodeDirectory")
+    if len(parts.apple_hash) != hashes.SHA256.digest_size:
+        raise BlobError("Apple cdhashes attribute needs a full SHA-256 digest")
+
+    digest = hashlib.sha256(code_directory).digest()
+    signing_time = parts.signing_time or datetime.datetime.now(datetime.timezone.utc)
+
+    signed_attrs = cms.CMSAttributes(
+        [
+            cms.CMSAttribute({"type": "content_type", "values": ["data"]}),
+            cms.CMSAttribute(
+                {
+                    "type": "signing_time",
+                    "values": [cms.Time({"utc_time": signing_time})],
+                }
+            ),
+            cms.CMSAttribute(
+                {"type": "message_digest", "values": [core.OctetString(digest)]}
+            ),
+            cms.CMSAttribute(
+                {
+                    "type": OID_APPLE_CDHASHES,
+                    "values": [core.Any.load(_apple_cdhash_attribute(parts.apple_hash))],
+                }
+            ),
+            cms.CMSAttribute(
+                {
+                    "type": OID_APPLE_CDHASHES_PLIST,
+                    "values": [core.OctetString(parts.cdhashes_plist)],
+                }
+            ),
+        ]
+    )
+
+    # RFC 5652: the signature covers the SET-encoded attributes, never the
+    # implicit [0] form the SignerInfo stores them in.
+    signature = identity.private_key.sign(
+        signed_attrs.dump(), padding.PKCS1v15(), hashes.SHA256()
+    )
+
+    leaf = identity.certificate
+    signer = cms.SignerInfo(
+        {
+            "version": "v1",
+            "sid": cms.SignerIdentifier(
+                {
+                    "issuer_and_serial_number": cms.IssuerAndSerialNumber(
+                        {
+                            "issuer": asn1x509.Name.load(leaf.issuer.public_bytes()),
+                            "serial_number": leaf.serial_number,
+                        }
+                    )
+                }
+            ),
+            "digest_algorithm": algos.DigestAlgorithm(
+                {"algorithm": "sha256", "parameters": None}
+            ),
+            "signed_attrs": signed_attrs,
+            "signature_algorithm": algos.SignedDigestAlgorithm(
+                {"algorithm": "rsassa_pkcs1v15"}
+            ),
+            "signature": signature,
+        }
+    )
+
+    certificates = cms.CertificateSet(
+        [cms.CertificateChoices({"certificate": _asn1_certificate(cert)}) for cert in identity.chain]
+    )
+
+    signed_data = cms.SignedData(
+        {
+            "version": "v1",
+            "digest_algorithms": cms.DigestAlgorithms(
+                [algos.DigestAlgorithm({"algorithm": "sha256", "parameters": None})]
+            ),
+            "encap_content_info": cms.ContentInfo({"content_type": "data"}),
+            "certificates": certificates,
+            "signer_infos": cms.SignerInfos([signer]),
+        }
+    )
+
+    return cms.ContentInfo(
+        {"content_type": "signed_data", "content": signed_data}
+    ).dump()
+
+
+def cms_content(cms_bytes: bytes) -> bytes | None:
+    """Return the detached content of a CMS blob, or None when absent."""
+    info = cms.ContentInfo.load(cms_bytes)
+    content = info["content"]["encap_content_info"]["content"]
+    return content.native if content.native else None
+
+
+__all__ = ["CmsParts", "build_cms"]

ipasign/credentials.py

@@ -0,0 +1,259 @@
+"""Signing identity and provisioning profile loading.
+
+A ``.p12`` holds the private key and the leaf certificate. A
+``.mobileprovision`` is a CMS-signed plist carrying the entitlements to seal and
+the team identifier. This module turns both into the pieces the signature
+builders want, and picks the intermediate certificate that completes the chain.
+"""
+
+from __future__ import annotations
+
+import plistlib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from cryptography import x509
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.primitives.serialization import pkcs12
+
+from . import _apple_ca
+from .errors import CredentialError, ProfileError
+
+
+@dataclass(slots=True)
+class ProvisioningProfile:
+    """The parts of a provisioning profile signing needs."""
+
+    data: bytes
+    entitlements: dict
+    entitlements_plist: bytes
+    team_id: str
+    application_id: str
+    developer_certificates: list[bytes] = field(default_factory=list)
+
+    @property
+    def get_task_allow(self) -> bool:
+        """True only when ``get-task-allow`` is present and set to a true value."""
+        return bool(self.entitlements.get("get-task-allow", False))
+
+    def matches(self, bundle_id: str) -> bool:
+        """Whether this profile was issued for ``bundle_id``."""
+        return bool(self.application_id) and self.application_id.endswith(bundle_id)
+
+
+def _plist_from_cms(data: bytes) -> dict:
+    """Pull the plist payload out of a CMS-wrapped provisioning profile."""
+    from asn1crypto import cms
+
+    try:
+        info = cms.ContentInfo.load(data)
+    except Exception as exc:  # asn1crypto raises several unrelated types
+        raise ProfileError(f"provisioning profile is not a CMS structure: {exc}") from exc
+
+    if info["content_type"].native != "signed_data":
+        raise ProfileError(f"provisioning profile content is {info['content_type'].native}")
+
+    content = info["content"]["encap_content_info"]["content"]
+    if content.native is None:
+        raise ProfileError("provisioning profile has no plist payload")
+
+    payload = content.native
+    try:
+        parsed = plistlib.loads(payload)
+    except Exception as exc:
+        raise ProfileError(f"provisioning profile payload is not a plist: {exc}") from exc
+    if not isinstance(parsed, dict):
+        raise ProfileError("provisioning profile payload is not a dictionary")
+    return parsed
+
+
+def load_profile(path: str | Path) -> ProvisioningProfile:
+    """Read a ``.mobileprovision`` file and pull out the signing inputs."""
+    try:
+        data = Path(path).read_bytes()
+    except FileNotFoundError as exc:
+        raise ProfileError(f"provisioning profile not found: {path}") from exc
+    except OSError as exc:
+        raise ProfileError(f"cannot read provisioning profile {path}: {exc}") from exc
+
+    if not data:
+        raise ProfileError(f"provisioning profile is empty: {path}")
+
+    plist = _plist_from_cms(data)
+
+    team_ids = plist.get("TeamIdentifier") or []
+    if not team_ids:
+        raise ProfileError("provisioning profile carries no TeamIdentifier")
+    team_id = team_ids[0]
+
+    entitlements = plist.get("Entitlements")
+    if not isinstance(entitlements, dict):
+        raise ProfileError("provisioning profile carries no Entitlements dictionary")
+
+    certificates = [
+        cert
+        for cert in (plist.get("DeveloperCertificates") or [])
+        if isinstance(cert, (bytes, bytearray))
+    ]
+
+    return ProvisioningProfile(
+        data=data,
+        entitlements=entitlements,
+        entitlements_plist=plistlib.dumps(entitlements, fmt=plistlib.FMT_XML, sort_keys=False),
+        team_id=team_id,
+        application_id=str(entitlements.get("application-identifier", "")),
+        developer_certificates=certificates,
+    )
+
+
+def _embedded_intermediate(leaf: x509.Certificate) -> x509.Certificate | None:
+    """The known Apple intermediate that issued ``leaf``, if any."""
+    for pem in _apple_ca.WWDR_BY_ISSUER_HASH.values():
+        candidate = x509.load_pem_x509_certificate(pem.encode("ascii"))
+        if candidate.subject == leaf.issuer:
+            return candidate
+    return None
+
+
+@dataclass(slots=True)
+class Identity:
+    """A loaded signing identity and the chain that completes it."""
+
+    private_key: rsa.RSAPrivateKey
+    certificate: x509.Certificate
+    chain: list[x509.Certificate]
+
+    @property
+    def subject_cn(self) -> str:
+        """The leaf certificate's common name, pinned by the requirement."""
+        for attr in self.certificate.subject:
+            if attr.oid == x509.oid.NameOID.COMMON_NAME:
+                return attr.value
+        raise CredentialError("leaf certificate has no subject common name")
+
+
+def _load_der_certificates(blobs: list[bytes]) -> list[x509.Certificate]:
+    certs: list[x509.Certificate] = []
+    for blob in blobs:
+        try:
+            certs.append(x509.load_der_x509_certificate(blob))
+        except Exception:
+            continue
+    return certs
+
+
+def _select_chain(
+    leaf: x509.Certificate,
+    from_p12: list[x509.Certificate],
+    from_profile: list[x509.Certificate],
+) -> list[x509.Certificate]:
+    """Pick the certificates to embed, intermediates first and the leaf last.
+
+    A chain carried inside the p12 is preferred, but only when it actually
+    contains the leaf's issuer. A p12 holding an unrelated or root-only chain
+    must not shadow the intermediate that matches the leaf.
+    """
+    candidates = from_p12 or from_profile
+    chain: list[x509.Certificate] = []
+    for cert in candidates:
+        if cert == leaf:
+            continue
+        if cert not in chain:
+            chain.append(cert)
+
+    issuer = leaf.issuer
+    if not any(cert.subject == issuer for cert in chain):
+        chain = []
+
+    if not chain:
+        embedded = _embedded_intermediate(leaf)
+        if embedded is None:
+            raise CredentialError(
+                "no certificate in the p12 or profile issued the leaf, and no "
+                f"known Apple intermediate matches its issuer ({issuer.rfc4514_string()})"
+            )
+        chain = [embedded]
+
+    # Terminate the chain with the Apple root that issued one of its members.
+    for pem in _apple_ca.ROOTS:
+        root = x509.load_pem_x509_certificate(pem.encode("ascii"))
+        if root in chain:
+            continue
+        if any(cert.issuer == root.subject for cert in chain):
+            chain.append(root)
+
+    chain.append(leaf)
+    return chain
+
+
+def load_identity(
+    p12_path: str | Path,
+    password: str | None,
+    profile: ProvisioningProfile | None = None,
+) -> Identity:
+    """Read a ``.p12`` and build the signing chain.
+
+    The key and leaf come from the p12. Intermediates come from the p12 when it
+    carries a usable chain, otherwise from the profile's developer certificates,
+    otherwise from the embedded Apple intermediates.
+    """
+    try:
+        data = Path(p12_path).read_bytes()
+    except FileNotFoundError as exc:
+        raise CredentialError(f"identity file not found: {p12_path}") from exc
+    except OSError as exc:
+        raise CredentialError(f"cannot read identity file {p12_path}: {exc}") from exc
+
+    secret = None if password is None else password.encode("utf-8")
+    try:
+        key, leaf, extras = pkcs12.load_key_and_certificates(data, secret)
+    except Exception as exc:
+        raise CredentialError(
+            f"cannot open {p12_path}: wrong password or not a PKCS#12 file ({exc})"
+        ) from exc
+
+    if key is None:
+        raise CredentialError(f"{p12_path} carries no private key")
+    if leaf is None:
+        raise CredentialError(f"{p12_path} carries no certificate")
+    if not isinstance(key, rsa.RSAPrivateKey):
+        raise CredentialError(f"only RSA signing keys are supported, got {type(key).__name__}")
+
+    if leaf.public_key().public_numbers() != key.public_key().public_numbers():
+        raise CredentialError(f"private key in {p12_path} does not match its certificate")
+
+    from_profile = _load_der_certificates(profile.developer_certificates) if profile else []
+    chain = _select_chain(leaf, list(extras or []), from_profile)
+    return Identity(private_key=key, certificate=leaf, chain=chain)
+
+
+def load_entitlements(path: str | Path) -> tuple[dict, bytes]:
+    """Read an entitlements plist supplied by the caller.
+
+    Returns the parsed dictionary and the plist bytes to seal, with the caller's
+    key order preserved.
+    """
+    try:
+        raw = Path(path).read_bytes()
+    except FileNotFoundError as exc:
+        raise CredentialError(f"entitlements file not found: {path}") from exc
+    except OSError as exc:
+        raise CredentialError(f"cannot read entitlements file {path}: {exc}") from exc
+
+    try:
+        parsed = plistlib.loads(raw)
+    except Exception as exc:
+        raise CredentialError(f"entitlements file {path} is not a plist: {exc}") from exc
+    if not isinstance(parsed, dict):
+        raise CredentialError(f"entitlements file {path} is not a dictionary")
+
+    return parsed, plistlib.dumps(parsed, fmt=plistlib.FMT_XML, sort_keys=False)
+
+
+__all__ = [
+    "Identity",
+    "ProvisioningProfile",
+    "load_entitlements",
+    "load_identity",
+    "load_profile",
+]

ipasign/errors.py

@@ -0,0 +1,56 @@
+"""Exception types raised by the public API.
+
+Everything the library raises derives from :class:`IpasignError`, so callers
+can catch one base class and still tell the failure modes apart.
+"""
+
+from __future__ import annotations
+
+
+class IpasignError(Exception):
+    """Base class for every error ipasign raises."""
+
+
+class InvalidInputError(IpasignError):
+    """The input is not something this library knows how to sign."""
+
+
+class MachOError(IpasignError):
+    """A Mach-O file is malformed or cannot be rewritten."""
+
+
+class BlobError(IpasignError):
+    """A code signature blob could not be built or parsed."""
+
+
+class CredentialError(IpasignError):
+    """A signing identity, password or provisioning profile is unusable."""
+
+
+class ProfileError(CredentialError):
+    """A provisioning profile could not be read or is missing required data."""
+
+
+class BundleError(IpasignError):
+    """A bundle is missing the structure signing requires."""
+
+
+class ArchiveError(IpasignError):
+    """An archive could not be unpacked or repacked."""
+
+
+class NotEnoughSpaceError(MachOError):
+    """The load commands have no room for a new LC_CODE_SIGNATURE."""
+
+
+__all__ = [
+    "IpasignError",
+    "InvalidInputError",
+    "MachOError",
+    "BlobError",
+    "CredentialError",
+    "ProfileError",
+    "BundleError",
+    "ArchiveError",
+    "NotEnoughSpaceError",
+]