Lightweight coding agent that runs in your terminal
Rust
Use Azure Key Vault for macOS notarization (#37154)
Eric Burke0c07c7ee4761
diff --git a/.github/scripts/macos-signing/notarize_macos_binary_with_rcodesign.sh b/.github/scripts/macos-signing/notarize_macos_binary_with_akv.shsimilarity index 58%rename from .github/scripts/macos-signing/notarize_macos_binary_with_rcodesign.shrename to .github/scripts/macos-signing/notarize_macos_binary_with_akv.shindex 8ebe490d41..9e053a97b3 100755--- a/.github/scripts/macos-signing/notarize_macos_binary_with_rcodesign.sh+++ b/.github/scripts/macos-signing/notarize_macos_binary_with_akv.sh@@ -1,19 +1,17 @@#!/usr/bin/env bash-# Submits a signed standalone macOS binary to Apple notarization through-# rcodesign. Standalone binaries cannot carry a stapled ticket, so the binary-# is submitted in a ZIP and the successful notarization log is retained.+# Notarize a standalone binary and retain its diagnostic report.set -euo pipefailusage() {cat >&2 <<'EOF'-Usage: notarize_macos_binary_with_rcodesign.sh --binary PATH [--report-dir PATH] [--max-wait-seconds SECONDS]+Usage: notarize_macos_binary_with_akv.sh --binary PATH [--report-dir PATH] [--max-wait-seconds SECONDS]Options:--binary PATH Signed standalone macOS binary to notarize.--report-dir PATH Directory for notarization logs.- --max-wait-seconds SECONDS Maximum rcodesign notarization wait time.+ --max-wait-seconds SECONDS Maximum Apple notarization wait time.EOF}@@ -63,7 +61,7 @@ if [[ ! "$max_wait_seconds" =~ ^[0-9]+$ ]]; thenexit 2fi-for command_name in rcodesign zip; do+for command_name in python3 zip; doif ! command -v "$command_name" >/dev/null 2>&1; thenecho "$command_name was not found on PATH." >&2exit 1@@ -73,11 +71,11 @@ donemissing_environment=0for variable_name in \APPLE_NOTARIZATION_ISSUER_ID \- APPLE_NOTARIZATION_KEY_ID \- APPLE_NOTARIZATION_KEY_P8+ APPLE_NOTARIZATION_AKV_KEY_NAME \+ AZURE_KEYVAULT_NAMEdoif [[ -z "${!variable_name:-}" ]]; then- echo "$variable_name must be set from CI secrets before notarizing a binary." >&2+ echo "$variable_name must be configured before notarizing a binary." >&2missing_environment=1fidone@@ -91,23 +89,6 @@ mkdir -p "$report_dir"notarization_temp_dir="$(mktemp -d)"trap 'rm -rf "$notarization_temp_dir" >/dev/null' EXIT-private_key_path="$notarization_temp_dir/AuthKey_${APPLE_NOTARIZATION_KEY_ID}.p8"-if ! printf '%s' "$APPLE_NOTARIZATION_KEY_P8" | base64 --decode >"$private_key_path" 2>/dev/null; then- if ! printf '%s' "$APPLE_NOTARIZATION_KEY_P8" | base64 -D >"$private_key_path" 2>/dev/null; then- echo "APPLE_NOTARIZATION_KEY_P8 must be a base64-encoded .p8 private key." >&2- exit 2- fi-fi-chmod 600 "$private_key_path"--api_key_path="$notarization_temp_dir/app-store-connect-api-key.json"-rcodesign encode-app-store-connect-api-key \- --output-path "$api_key_path" \- "$APPLE_NOTARIZATION_ISSUER_ID" \- "$APPLE_NOTARIZATION_KEY_ID" \- "$private_key_path" \- >"$report_dir/encode-app-store-connect-api-key.log" 2>&1-binary_name="$(basename "$binary_path")"archive_path="$notarization_temp_dir/${binary_name}.zip"(@@ -116,16 +97,15 @@ archive_path="$notarization_temp_dir/${binary_name}.zip")notarization_log="$report_dir/${binary_name}-notarization.log"-rcodesign notarize \- --api-key-file "$api_key_path" \+python3 "$(dirname "$0")/notarize_with_akv.py" \+ --file "$archive_path" \+ --report-log "$report_dir/${binary_name}-notarization-developer-log.json" \--max-wait-seconds "$max_wait_seconds" \- --wait \- "$archive_path" \2>&1 | tee "$notarization_log"{echo "binary_name=$binary_name"echo "max_wait_seconds=$max_wait_seconds"echo "binary_sha256=$(shasum -a 256 "$binary_path" | awk '{ print $1 }')"- echo "rcodesign_notarize=completed"+ echo "notarization=completed"} >"$report_dir/${binary_name}-notarization-summary.txt"diff --git a/.github/scripts/macos-signing/notarize_macos_dmg_with_rcodesign.sh b/.github/scripts/macos-signing/notarize_macos_dmg_with_akv.shsimilarity index 52%rename from .github/scripts/macos-signing/notarize_macos_dmg_with_rcodesign.shrename to .github/scripts/macos-signing/notarize_macos_dmg_with_akv.shindex a1125d436a..3433bacc46 100755--- a/.github/scripts/macos-signing/notarize_macos_dmg_with_rcodesign.sh+++ b/.github/scripts/macos-signing/notarize_macos_dmg_with_akv.sh@@ -1,21 +1,17 @@#!/usr/bin/env bash-# Notarizes and staples a signed macOS DMG through rcodesign.-#-# This is the Linux-compatible notarization path for the AKV/PKCS#11 signing-# flow. It records notarization inputs and logs so workflow artifacts can be-# audited without exposing the App Store Connect private key.+# Notarize a signed disk image and staple its ticket.set -euo pipefailusage() {cat >&2 <<'EOF'-Usage: notarize_macos_dmg_with_rcodesign.sh --dmg PATH [--report-dir PATH] [--max-wait-seconds SECONDS]+Usage: notarize_macos_dmg_with_akv.sh --dmg PATH [--report-dir PATH] [--max-wait-seconds SECONDS]Options:--dmg PATH Signed DMG to submit to Apple notarization.--report-dir PATH Directory for notarization logs.- --max-wait-seconds SECONDS Maximum rcodesign notarization wait time.+ --max-wait-seconds SECONDS Maximum Apple notarization wait time.EOF}@@ -73,11 +69,11 @@ fimissing_environment=0for variable_name in \APPLE_NOTARIZATION_ISSUER_ID \- APPLE_NOTARIZATION_KEY_ID \- APPLE_NOTARIZATION_KEY_P8+ APPLE_NOTARIZATION_AKV_KEY_NAME \+ AZURE_KEYVAULT_NAMEdoif [[ -z "${!variable_name:-}" ]]; then- echo "$variable_name must be set from CI secrets before notarizing a DMG." >&2+ echo "$variable_name must be configured before notarizing a DMG." >&2missing_environment=1fidone@@ -88,37 +84,18 @@ fimkdir -p "$report_dir"-notarization_temp_dir="$(mktemp -d)"-trap 'rm -rf "$notarization_temp_dir" > /dev/null' EXIT--private_key_path="$notarization_temp_dir/AuthKey_${APPLE_NOTARIZATION_KEY_ID}.p8"-if ! printf '%s' "$APPLE_NOTARIZATION_KEY_P8" | base64 --decode > "$private_key_path" 2> /dev/null; then- if ! printf '%s' "$APPLE_NOTARIZATION_KEY_P8" | base64 -D > "$private_key_path" 2> /dev/null; then- echo "APPLE_NOTARIZATION_KEY_P8 must be a base64-encoded .p8 private key." >&2- exit 2- fi-fi-chmod 600 "$private_key_path"--api_key_path="$notarization_temp_dir/app-store-connect-api-key.json"-rcodesign encode-app-store-connect-api-key \- --output-path "$api_key_path" \- "$APPLE_NOTARIZATION_ISSUER_ID" \- "$APPLE_NOTARIZATION_KEY_ID" \- "$private_key_path" \- > "$report_dir/encode-app-store-connect-api-key.log" 2>&1-notarization_log="$report_dir/dmg-notarization.log"-rcodesign notarize \- --api-key-file "$api_key_path" \+python3 "$(dirname "$0")/notarize_with_akv.py" \+ --file "$dmg_path" \+ --report-log "$report_dir/dmg-notarization-developer-log.json" \--max-wait-seconds "$max_wait_seconds" \- --staple \- "$dmg_path" \2>&1 | tee "$notarization_log"+rcodesign staple "$dmg_path" 2>&1 | tee -a "$notarization_log"+{echo "dmg_path=$dmg_path"echo "max_wait_seconds=$max_wait_seconds"echo "dmg_sha256=$(shasum -a 256 "$dmg_path" | awk '{ print $1 }')"- echo "rcodesign_notarize_staple=completed"+ echo "notarization_staple=completed"} > "$report_dir/dmg-notarization-summary.txt"diff --git a/.github/scripts/macos-signing/notarize_with_akv.py b/.github/scripts/macos-signing/notarize_with_akv.pynew file mode 100644index 0000000000..ece64dca3f--- /dev/null+++ b/.github/scripts/macos-signing/notarize_with_akv.py@@ -0,0 +1,460 @@+#!/usr/bin/env python3+"""Submit release artifacts for notarization and wait for the result."""++import argparse+import base64+import datetime+import hashlib+import hmac+import json+import os+import re+import subprocess+import sys+import time+import urllib.error+import urllib.parse+import urllib.request+from dataclasses import dataclass+from pathlib import Path+from typing import Any++APPLE_NOTARY_URL = "https://appstoreconnect.apple.com/notary/v2/submissions"+AZURE_KEYVAULT_API_VERSION = "7.4"+AWS_REGION = "us-west-2"+JWT_LIFETIME_SECONDS = 15 * 60+POLL_INTERVAL_SECONDS = 10+MAX_SINGLE_UPLOAD_BYTES = 5 * 1024 * 1024 * 1024+++class NotarizationError(RuntimeError):+ """Describe a notarization failure."""+++@dataclass(frozen=True)+class NotarizationConfiguration:+ """Hold the account and signing-key configuration."""++ issuer_id: str+ apple_key_id: str+ vault_name: str+ vault_key_name: str+ vault_key_version: str++ @classmethod+ def from_environment(cls) -> "NotarizationConfiguration":+ """Load and validate the notarization configuration."""++ required = {+ "issuer_id": "APPLE_NOTARIZATION_ISSUER_ID",+ "vault_name": "AZURE_KEYVAULT_NAME",+ "vault_key_name": "APPLE_NOTARIZATION_AKV_KEY_NAME",+ }+ values = {field: os.environ.get(name, "").strip() for field, name in required.items()}+ missing = [name for field, name in required.items() if not values[field]]+ if missing:+ raise NotarizationError("Missing notarization configuration: " + ", ".join(missing))+ if not re.fullmatch(r"[A-Za-z][A-Za-z0-9-]{2,23}", values["vault_name"]):+ raise NotarizationError("Invalid signing vault name")+ if not re.fullmatch(r"[A-Za-z0-9-]+", values["vault_key_name"]):+ raise NotarizationError("Invalid notarization key name")+ key_version = os.environ.get("APPLE_NOTARIZATION_AKV_KEY_VERSION", "").strip()+ if key_version and not re.fullmatch(r"[0-9a-fA-F]{32}", key_version):+ raise NotarizationError(+ "Notarization key must resolve to a 32-character pinned version"+ )++ command = [+ "az",+ "keyvault",+ "key",+ "show",+ "--vault-name",+ values["vault_name"],+ "--name",+ values["vault_key_name"],+ ]+ if key_version:+ command.extend(["--version", key_version])+ command.extend(+ [+ "--query",+ '{id:key.kid,apple_key_id:tags."apple-key-id"}',+ "--output",+ "json",+ "--only-show-errors",+ ]+ )++ # Resolve the key identifier and version from the same lookup.+ try:+ result = subprocess.run(command, check=True, capture_output=True, text=True)+ except (OSError, subprocess.CalledProcessError) as error:+ raise NotarizationError("Notarization signing key could not be read") from error+ try:+ metadata = json.loads(result.stdout)+ returned_key_id = metadata["id"]+ apple_key_id = metadata["apple_key_id"]+ except (json.JSONDecodeError, KeyError, TypeError) as error:+ raise NotarizationError("Notarization key metadata is invalid") from error++ key_id_prefix = (+ f"https://{values['vault_name']}.vault.azure.net/keys/{values['vault_key_name']}/"+ )+ if not isinstance(returned_key_id, str) or not returned_key_id.startswith(key_id_prefix):+ raise NotarizationError("Unexpected notarization signing key")+ returned_key_version = returned_key_id[len(key_id_prefix) :]+ if not re.fullmatch(r"[0-9a-fA-F]{32}", returned_key_version):+ raise NotarizationError(+ "Notarization key must resolve to a 32-character pinned version"+ )+ if key_version and returned_key_version.lower() != key_version.lower():+ raise NotarizationError("Unexpected notarization key version")+ if not isinstance(apple_key_id, str) or not apple_key_id.strip():+ raise NotarizationError("Notarization key must have an apple-key-id tag")++ values["apple_key_id"] = apple_key_id.strip()+ values["vault_key_version"] = returned_key_version+ return cls(**values)++ @property+ def versioned_key_id(self) -> str:+ """Return the versioned signing-key identifier."""++ return (+ f"https://{self.vault_name}.vault.azure.net/keys/"+ f"{self.vault_key_name}/{self.vault_key_version}"+ )+++def base64url_encode(value: bytes) -> str:+ """Encode bytes using the unpadded base64url format required by JWTs."""++ return base64.urlsafe_b64encode(value).decode("ascii").rstrip("=")+++def base64url_decode(value: str) -> bytes:+ """Decode a base64url value and reject malformed input."""++ try:+ return base64.b64decode(value + "=" * (-len(value) % 4), altchars=b"-_", validate=True)+ except (ValueError, UnicodeEncodeError) as error:+ raise NotarizationError("Signing service returned an invalid signature") from error+++def create_apple_jwt(configuration: NotarizationConfiguration, *, issued_at: int) -> str:+ """Create an authentication token for notarization requests."""++ header = {"alg": "ES256", "kid": configuration.apple_key_id, "typ": "JWT"}+ # Restrict the token to notarization requests.+ claims = {+ "iss": configuration.issuer_id,+ "iat": issued_at,+ "exp": issued_at + JWT_LIFETIME_SECONDS,+ "aud": "appstoreconnect-v1",+ "scope": ["/notary/v2"],+ }+ encoded_header = base64url_encode(json.dumps(header, separators=(",", ":")).encode("utf-8"))+ encoded_claims = base64url_encode(json.dumps(claims, separators=(",", ":")).encode("utf-8"))+ signing_input = f"{encoded_header}.{encoded_claims}"+ digest = hashlib.sha256(signing_input.encode("ascii")).digest()+ key_url = configuration.versioned_key_id+ request_body = json.dumps({"alg": "ES256", "value": base64url_encode(digest)})++ try:+ result = subprocess.run(+ [+ "az",+ "rest",+ "--method",+ "post",+ "--url",+ f"{key_url}/sign?api-version={AZURE_KEYVAULT_API_VERSION}",+ "--resource",+ "https://vault.azure.net",+ "--headers",+ "Content-Type=application/json",+ "--body",+ request_body,+ "--output",+ "json",+ "--only-show-errors",+ ],+ check=True,+ capture_output=True,+ text=True,+ )+ except (OSError, subprocess.CalledProcessError) as error:+ detail = getattr(error, "stderr", "").strip()+ message = "Signing service could not sign the authentication token"+ if detail:+ message = f"{message}: {detail}"+ raise NotarizationError(message) from error++ try:+ response = json.loads(result.stdout)+ returned_key_id = response["kid"]+ encoded_signature = response["value"]+ except (json.JSONDecodeError, KeyError, TypeError) as error:+ raise NotarizationError("Signing service returned an invalid response") from error++ # Reject signatures generated with a different key version.+ if returned_key_id != key_url:+ raise NotarizationError("Signing service returned an unexpected key version")+ if not isinstance(encoded_signature, str):+ raise NotarizationError("Signing service returned an invalid signature")+ signature = base64url_decode(encoded_signature)+ # ES256 JWT signatures are 64 raw R || S bytes, not ASN.1/DER-encoded ECDSA signatures.+ if len(signature) != 64:+ raise NotarizationError("ES256 signature must contain 64 JOSE R || S bytes")+ return f"{signing_input}.{base64url_encode(signature)}"+++def json_request(url: str, token: str, *, body: dict[str, Any] | None = None) -> dict[str, Any]:+ """Send an authenticated JSON request to Apple's notarization service."""++ data = None if body is None else json.dumps(body).encode("utf-8")+ request = urllib.request.Request(+ url,+ data=data,+ method="GET" if body is None else "POST",+ headers={+ "Accept": "application/json",+ "Authorization": f"Bearer {token}",+ "Content-Type": "application/json",+ },+ )+ try:+ with urllib.request.urlopen(request, timeout=60) as response:+ result = json.load(response)+ except urllib.error.HTTPError as error:+ detail = error.read(1024).decode("utf-8", errors="replace")+ raise NotarizationError(f"Apple Notary API returned HTTP {error.code}: {detail}") from error+ except (OSError, json.JSONDecodeError) as error:+ raise NotarizationError("Apple Notary API request failed") from error++ if not isinstance(result, dict):+ raise NotarizationError("Apple Notary API returned an invalid response")+ return result+++def sha256_file(path: Path) -> str:+ """Hash an artifact incrementally so large release files stay off the heap."""++ digest = hashlib.sha256()+ with path.open("rb") as source:+ for chunk in iter(lambda: source.read(1024 * 1024), b""):+ digest.update(chunk)+ return digest.hexdigest()+++def hmac_sha256(key: bytes, value: str) -> bytes:+ """Derive one AWS Signature Version 4 signing-key component."""++ return hmac.new(key, value.encode("utf-8"), hashlib.sha256).digest()+++def upload_to_apple_s3(+ path: Path,+ file_digest: str,+ credentials: dict[str, Any],+ *,+ timestamp: datetime.datetime | None = None,+) -> None:+ """Upload an artifact using the provided temporary credentials."""++ required = (+ "awsAccessKeyId",+ "awsSecretAccessKey",+ "awsSessionToken",+ "bucket",+ "object",+ )+ if any(+ not isinstance(credentials.get(name), str) or not credentials[name] for name in required+ ):+ raise NotarizationError("Apple returned incomplete temporary upload credentials")++ size = path.stat().st_size+ if not 0 < size <= MAX_SINGLE_UPLOAD_BYTES:+ raise NotarizationError("Notarization payload must be between 1 byte and 5 GiB")++ now = timestamp or datetime.datetime.now(datetime.timezone.utc)+ amz_date = now.strftime("%Y%m%dT%H%M%SZ")+ date_stamp = now.strftime("%Y%m%d")+ host = f"{credentials['bucket']}.s3.{AWS_REGION}.amazonaws.com"+ object_path = "/" + urllib.parse.quote(credentials["object"].lstrip("/"), safe="/-_.~")+ headers = {+ "content-type": "application/octet-stream",+ "host": host,+ "x-amz-content-sha256": file_digest,+ "x-amz-date": amz_date,+ "x-amz-security-token": credentials["awsSessionToken"],+ }+ # Build the signature required by the upload endpoint.+ signed_headers = ";".join(sorted(headers))+ canonical_headers = "".join(f"{name}:{headers[name]}\n" for name in sorted(headers))+ canonical_request = "\n".join(+ ["PUT", object_path, "", canonical_headers, signed_headers, file_digest]+ )+ credential_scope = f"{date_stamp}/{AWS_REGION}/s3/aws4_request"+ string_to_sign = "\n".join(+ [+ "AWS4-HMAC-SHA256",+ amz_date,+ credential_scope,+ hashlib.sha256(canonical_request.encode("utf-8")).hexdigest(),+ ]+ )+ signing_key = ("AWS4" + credentials["awsSecretAccessKey"]).encode("utf-8")+ for component in (date_stamp, AWS_REGION, "s3", "aws4_request"):+ signing_key = hmac_sha256(signing_key, component)+ signature = hmac.new(signing_key, string_to_sign.encode("utf-8"), hashlib.sha256).hexdigest()+ authorization = (+ "AWS4-HMAC-SHA256 "+ f"Credential={credentials['awsAccessKeyId']}/{credential_scope}, "+ f"SignedHeaders={signed_headers}, Signature={signature}"+ )++ # Stream the artifact to avoid buffering its full contents.+ with path.open("rb") as source:+ request = urllib.request.Request(+ f"https://{host}{object_path}",+ data=source,+ method="PUT",+ headers={+ **headers,+ "Authorization": authorization,+ "Content-Length": str(size),+ },+ )+ try:+ with urllib.request.urlopen(request, timeout=300):+ pass+ except urllib.error.HTTPError as error:+ raise NotarizationError(+ f"Apple notarization payload upload failed with HTTP {error.code}"+ ) from error+ except OSError as error:+ raise NotarizationError("Apple notarization payload upload failed") from error+++def write_developer_log(submission_id: str, token: str, destination: Path | None) -> None:+ """Write the submission's optional diagnostic report."""++ if destination is None:+ return+ response = json_request(f"{APPLE_NOTARY_URL}/{submission_id}/logs", token)+ try:+ log_url = response["data"]["attributes"]["developerLogUrl"]+ except (KeyError, TypeError) as error:+ raise NotarizationError("Apple did not provide a notarization developer log") from error+ if not isinstance(log_url, str) or not log_url.startswith("https://"):+ raise NotarizationError("Apple returned an invalid notarization developer log URL")+ try:+ # Do not forward unrelated authorization headers to the download URL.+ with urllib.request.urlopen(log_url, timeout=60) as response:+ destination.write_bytes(response.read())+ except urllib.error.HTTPError as error:+ raise NotarizationError(+ f"Apple notarization developer log download failed with HTTP {error.code}"+ ) from error+ except OSError as error:+ raise NotarizationError("Apple notarization developer log download failed") from error+++def notarize(+ path: Path,+ configuration: NotarizationConfiguration,+ *,+ max_wait_seconds: int,+ report_log: Path | None,+) -> str:+ """Submit an artifact, upload it to Apple, and wait for a terminal result."""++ issued_at = int(time.time())+ token = create_apple_jwt(configuration, issued_at=issued_at)+ file_digest = sha256_file(path)+ # Create the submission before uploading the artifact.+ response = json_request(+ APPLE_NOTARY_URL,+ token,+ body={"sha256": file_digest, "submissionName": path.name},+ )+ try:+ submission_id = response["data"]["id"]+ upload_credentials = response["data"]["attributes"]+ except (KeyError, TypeError) as error:+ raise NotarizationError("Apple returned an invalid notarization submission") from error+ if not isinstance(submission_id, str) or not submission_id:+ raise NotarizationError("Apple did not return a notarization submission ID")+ if not isinstance(upload_credentials, dict):+ raise NotarizationError("Apple returned invalid notarization upload credentials")++ print(f"Uploading notarization submission {submission_id} for {path.name}")+ upload_to_apple_s3(path, file_digest, upload_credentials)+ # A monotonic deadline keeps the wait limit stable if the system clock changes.+ deadline = time.monotonic() + max_wait_seconds++ # Wait for completion, equivalent to `notarytool submit --wait`.+ while True:+ # Refresh the token before it expires.+ if int(time.time()) >= issued_at + JWT_LIFETIME_SECONDS - 60:+ issued_at = int(time.time())+ token = create_apple_jwt(configuration, issued_at=issued_at)+ result = json_request(f"{APPLE_NOTARY_URL}/{submission_id}", token)+ try:+ status = result["data"]["attributes"]["status"]+ except (KeyError, TypeError) as error:+ raise NotarizationError("Apple returned an invalid notarization status") from error++ if status in {"Accepted", "Invalid", "Rejected"}:+ # Save diagnostics for both accepted and rejected submissions.+ write_developer_log(submission_id, token, report_log)+ message = f"Notarization submission {submission_id} completed with status {status}"+ if status != "Accepted":+ raise NotarizationError(message)+ print(message)+ return submission_id+ if status != "In Progress":+ raise NotarizationError(f"Unexpected notarization status: {status!r}")++ remaining = deadline - time.monotonic()+ if remaining <= 0:+ raise NotarizationError(+ f"Notarization submission {submission_id} exceeded {max_wait_seconds} seconds"+ )+ print(f"Notarization submission {submission_id} is still in progress")+ time.sleep(min(POLL_INTERVAL_SECONDS, remaining))+++def main() -> int:+ """Run notarization using command-line arguments."""++ parser = argparse.ArgumentParser()+ parser.add_argument("--file", type=Path, required=True)+ parser.add_argument("--report-log", type=Path)+ parser.add_argument("--max-wait-seconds", type=int, default=600)+ arguments = parser.parse_args()++ try:+ if not arguments.file.is_file():+ raise NotarizationError(f"Notarization payload does not exist: {arguments.file}")+ if arguments.max_wait_seconds < 0:+ raise NotarizationError("--max-wait-seconds must be non-negative")+ if arguments.report_log is not None:+ arguments.report_log.parent.mkdir(parents=True, exist_ok=True)+ notarize(+ arguments.file,+ NotarizationConfiguration.from_environment(),+ max_wait_seconds=arguments.max_wait_seconds,+ report_log=arguments.report_log,+ )+ except NotarizationError as error:+ print(f"Notarization failed: {error}", file=sys.stderr)+ return 1+ return 0+++if __name__ == "__main__":+ raise SystemExit(main())diff --git a/.github/scripts/macos-signing/test_notarize_with_akv.py b/.github/scripts/macos-signing/test_notarize_with_akv.pynew file mode 100644index 0000000000..2a5f0b5457--- /dev/null+++ b/.github/scripts/macos-signing/test_notarize_with_akv.py@@ -0,0 +1,202 @@+import contextlib+import hashlib+import io+import json+import os+import subprocess+import sys+import tempfile+import unittest+from pathlib import Path+from unittest.mock import patch++SIGNING_DIRECTORY = Path(__file__).resolve().parent+sys.path.insert(0, str(SIGNING_DIRECTORY))+import notarize_with_akv as notary # noqa: E402++CONFIGURATION = notary.NotarizationConfiguration(+ "issuer-id",+ "APPLEKEY01",+ "notary-vault",+ "example-signing-key",+ "0123456789abcdef" * 2,+)+ENVIRONMENT = {+ "APPLE_NOTARIZATION_ISSUER_ID": CONFIGURATION.issuer_id,+ "AZURE_KEYVAULT_NAME": CONFIGURATION.vault_name,+ "APPLE_NOTARIZATION_AKV_KEY_NAME": CONFIGURATION.vault_key_name,+}+CREDENTIALS = {+ "awsAccessKeyId": "temporary-access-key",+ "awsSecretAccessKey": "temporary-secret-key",+ "awsSessionToken": "temporary-session-token",+ "bucket": "apple-notary-bucket",+ "object": "uploads/release artifact.dmg",+}+++def response(payload):+ return io.BytesIO(json.dumps(payload).encode() if isinstance(payload, dict) else payload)+++def azure_response(payload):+ return subprocess.CompletedProcess([], 0, stdout=json.dumps(payload), stderr="")+++class NotarizationTest(unittest.TestCase):+ def test_validates_the_apple_key_tag_and_pins_its_version(self) -> None:+ metadata = {"id": CONFIGURATION.versioned_key_id, "apple_key_id": "APPLEKEY01"}+ with (+ patch.dict(os.environ, ENVIRONMENT, clear=True),+ patch.object(+ notary.subprocess,+ "run",+ return_value=azure_response(metadata),+ ) as show,+ ):+ self.assertEqual(+ notary.NotarizationConfiguration.from_environment(),+ CONFIGURATION,+ )+ show.return_value = azure_response({**metadata, "apple_key_id": None})+ with self.assertRaisesRegex(notary.NotarizationError, "apple-key-id tag"):+ notary.NotarizationConfiguration.from_environment()+ self.assertIn('{id:key.kid,apple_key_id:tags."apple-key-id"}', show.call_args.args[0])++ invalid_environment = {**ENVIRONMENT, "APPLE_NOTARIZATION_AKV_KEY_NAME": "../bad"}+ with (+ patch.dict(os.environ, invalid_environment, clear=True),+ self.assertRaisesRegex(notary.NotarizationError, "key name"),+ ):+ notary.NotarizationConfiguration.from_environment()++ def test_signs_the_notary_scoped_digest_with_the_pinned_key(self) -> None:+ signature = bytes(range(64))+ payload = {+ "kid": CONFIGURATION.versioned_key_id,+ "value": notary.base64url_encode(signature),+ }+ with patch.object(notary.subprocess, "run", return_value=azure_response(payload)) as sign:+ token = notary.create_apple_jwt(CONFIGURATION, issued_at=1_780_000_000)+ header, claims, encoded_signature = token.split(".")+ self.assertEqual(json.loads(notary.base64url_decode(header))["kid"], "APPLEKEY01")+ self.assertEqual(+ json.loads(notary.base64url_decode(claims))["scope"],+ ["/notary/v2"],+ )+ self.assertEqual(notary.base64url_decode(encoded_signature), signature)+ command = sign.call_args.args[0]+ body = json.loads(command[command.index("--body") + 1])+ self.assertEqual(body["alg"], "ES256")+ self.assertEqual(+ notary.base64url_decode(body["value"]),+ hashlib.sha256(f"{header}.{claims}".encode()).digest(),+ )++ def test_rejects_wrong_key_versions_and_invalid_signatures(self) -> None:+ cases = (+ (CONFIGURATION.versioned_key_id + "wrong", bytes(64), "unexpected key version"),+ (CONFIGURATION.versioned_key_id, b"short", "64 JOSE"),+ )+ for key_id, signature, message in cases:+ payload = {"kid": key_id, "value": notary.base64url_encode(signature)}+ with (+ self.subTest(message=message),+ patch.object(+ notary.subprocess,+ "run",+ return_value=azure_response(payload),+ ),+ self.assertRaisesRegex(notary.NotarizationError, message),+ ):+ notary.create_apple_jwt(CONFIGURATION, issued_at=1)++ def test_uploads_polls_and_retains_sanitized_apple_diagnostics(self) -> None:+ signature = azure_response(+ {+ "kid": CONFIGURATION.versioned_key_id,+ "value": notary.base64url_encode(bytes(64)),+ }+ )+ responses = [+ response({"data": {"id": "submission-1", "attributes": CREDENTIALS}}),+ response(b""),+ response({"data": {"attributes": {"status": "In Progress"}}}),+ response({"data": {"attributes": {"status": "Accepted"}}}),+ response({"data": {"attributes": {"developerLogUrl": "https://logs.example.com/log"}}}),+ response(b'{"status":"Accepted"}'),+ ]+ with tempfile.TemporaryDirectory() as directory:+ artifact, log = (+ Path(directory) / "codex.zip",+ Path(directory) / "notary-log.json",+ )+ artifact.write_bytes(b"signed release binary")+ output = io.StringIO()+ with (+ patch.object(notary.subprocess, "run", return_value=signature),+ patch.object(notary.urllib.request, "urlopen", side_effect=responses) as requests,+ patch.object(notary.time, "sleep") as sleep,+ contextlib.redirect_stdout(output),+ ):+ submission = notary.notarize(+ artifact, CONFIGURATION, max_wait_seconds=600, report_log=log+ )+ self.assertEqual(submission, "submission-1")+ self.assertEqual(json.loads(log.read_text()), {"status": "Accepted"})+ sleep.assert_called_once_with(10)+ upload = requests.call_args_list[1].args[0]+ self.assertEqual(upload.get_method(), "PUT")+ self.assertNotIn("temporary-secret-key", upload.get_header("Authorization"))+ self.assertNotIn("temporary-secret-key", output.getvalue())+++class NotarizationWrapperTest(unittest.TestCase):+ def test_binary_and_dmg_wrappers_preserve_notarization_contracts(+ self,+ ) -> None:+ with tempfile.TemporaryDirectory() as directory:+ root, tools = Path(directory), Path(directory) / "tools"+ tools.mkdir()+ call_log = root / "calls.txt"+ environment = {+ **os.environ,+ **ENVIRONMENT,+ "PATH": f"{tools}:{os.environ['PATH']}",+ "RUNNER_TEMP": str(root),+ "CALL_LOG": str(call_log),+ }+ for name in ("az", "python3", "rcodesign"):+ body = "exit 0" if name == "az" else f'printf "{name} %s\\n" "$*" >> "$CALL_LOG"'+ executable = tools / name+ executable.write_text(f"#!/usr/bin/env bash\nset -euo pipefail\n{body}\n")+ executable.chmod(0o755)+ for kind in ("binary", "dmg"):+ with self.subTest(kind=kind):+ artifact = root / ("codex.dmg" if kind == "dmg" else "codex")+ artifact.write_bytes(b"signed release artifact")+ subprocess.run(+ [+ str(SIGNING_DIRECTORY / f"notarize_macos_{kind}_with_akv.sh"),+ f"--{kind}",+ str(artifact),+ "--report-dir",+ str(root / "report"),+ ],+ env=environment,+ check=True,+ capture_output=True,+ text=True,+ )+ calls = call_log.read_text().splitlines()+ self.assertIn("notarize_with_akv.py --file", calls[0])+ if kind == "dmg":+ self.assertEqual(calls[1], f"rcodesign staple {artifact}")+ else:+ self.assertEqual(len(calls), 1)+ self.assertEqual(list(root.rglob("*.p8")), [])+ call_log.unlink()+++if __name__ == "__main__":+ unittest.main()diff --git a/.github/workflows/repo-checks.yml b/.github/workflows/repo-checks.ymlindex 97932c4fd4..6c82ebcd0c 100644--- a/.github/workflows/repo-checks.yml+++ b/.github/workflows/repo-checks.yml@@ -33,6 +33,9 @@ jobs:- name: Test standalone installerrun: python3 -m unittest discover -s scripts/install -p 'test_*.py'+ - name: Test macOS notarization+ run: python3 -m unittest discover -s .github/scripts/macos-signing -p 'test_notarize_with_akv.py'+- name: Setup pnpmuses: pnpm/action-setup@a8198c4bff370c8506180b035930dea56dbd5288 # v5with:diff --git a/.github/workflows/rust-release.yml b/.github/workflows/rust-release.ymlindex 1b423273af..72b6e23895 100644--- a/.github/workflows/rust-release.yml+++ b/.github/workflows/rust-release.yml@@ -538,9 +538,9 @@ jobs:env:TARGET: ${{ matrix.target }}BINARIES: ${{ matrix.binaries }}- APPLE_NOTARIZATION_KEY_P8: ${{ secrets.APPLE_NOTARIZATION_KEY_P8 }}- APPLE_NOTARIZATION_KEY_ID: ${{ secrets.APPLE_NOTARIZATION_KEY_ID }}APPLE_NOTARIZATION_ISSUER_ID: ${{ secrets.APPLE_NOTARIZATION_ISSUER_ID }}+ APPLE_NOTARIZATION_AKV_KEY_NAME: ${{ secrets.AKV_NOTARIZATION_KEY_NAME }}+ APPLE_NOTARIZATION_AKV_KEY_VERSION: ${{ secrets.AKV_NOTARIZATION_KEY_VERSION }}run: |set -euo pipefail@@ -579,7 +579,7 @@ jobs:rcodesign print-signature-info "$signed_path" \>"${report_dir}/${binary}/signature-info.yaml"- .github/scripts/macos-signing/notarize_macos_binary_with_rcodesign.sh \+ .github/scripts/macos-signing/notarize_macos_binary_with_akv.sh \--binary "$signed_path" \--report-dir "${report_dir}/${binary}"done@@ -589,9 +589,9 @@ jobs:shell: bashenv:TARGET: ${{ matrix.target }}- APPLE_NOTARIZATION_KEY_P8: ${{ secrets.APPLE_NOTARIZATION_KEY_P8 }}- APPLE_NOTARIZATION_KEY_ID: ${{ secrets.APPLE_NOTARIZATION_KEY_ID }}APPLE_NOTARIZATION_ISSUER_ID: ${{ secrets.APPLE_NOTARIZATION_ISSUER_ID }}+ APPLE_NOTARIZATION_AKV_KEY_NAME: ${{ secrets.AKV_NOTARIZATION_KEY_NAME }}+ APPLE_NOTARIZATION_AKV_KEY_VERSION: ${{ secrets.AKV_NOTARIZATION_KEY_VERSION }}run: |set -euo pipefail@@ -636,7 +636,7 @@ jobs:rcodesign print-signature-info "$binary" \>"${report_dir}/signature-info.yaml"- .github/scripts/macos-signing/notarize_macos_binary_with_rcodesign.sh \+ .github/scripts/macos-signing/notarize_macos_binary_with_akv.sh \--binary "$binary" \--report-dir "$report_dir"done@@ -923,9 +923,9 @@ jobs:shell: bashenv:TARGET: ${{ matrix.target }}- APPLE_NOTARIZATION_KEY_P8: ${{ secrets.APPLE_NOTARIZATION_KEY_P8 }}- APPLE_NOTARIZATION_KEY_ID: ${{ secrets.APPLE_NOTARIZATION_KEY_ID }}APPLE_NOTARIZATION_ISSUER_ID: ${{ secrets.APPLE_NOTARIZATION_ISSUER_ID }}+ APPLE_NOTARIZATION_AKV_KEY_NAME: ${{ secrets.AKV_NOTARIZATION_KEY_NAME }}+ APPLE_NOTARIZATION_AKV_KEY_VERSION: ${{ secrets.AKV_NOTARIZATION_KEY_VERSION }}run: |set -euo pipefail@@ -946,7 +946,7 @@ jobs:rcodesign print-signature-info "$dmg_path" \>"${report_dir}/signature-info-before-notarization.yaml"- .github/scripts/macos-signing/notarize_macos_dmg_with_rcodesign.sh \+ .github/scripts/macos-signing/notarize_macos_dmg_with_akv.sh \--dmg "$dmg_path" \--report-dir "$report_dir"