protool 2.0.0__tar.gz → 3.0.0__tar.gz

{protool-2.0.0 → protool-3.0.0}/PKG-INFO

@@ -1,26 +1,28 @@
 Metadata-Version: 2.1
 Name: protool
-Version: 2.0.0
+Version: 3.0.0
 Summary: A tool for dealing with provisioning profiles
 Home-page: https://github.com/Microsoft/protool
 License: MIT
 Keywords: provisioning,profiles,apple,ios,xcode,mobileprovision
 Author: Dale Myers
 Author-email: dalemy@microsoft.com
-Requires-Python: >=3.8,<4.0
+Requires-Python: >=3.11,<4.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Environment :: MacOS X
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development
 Classifier: Topic :: Utilities
-Requires-Dist: pyOpenSSL (>=23.2.0,<24.0.0)
+Requires-Dist: pyOpenSSL (>=25.1.0,<26.0.0)
 Project-URL: Repository, https://github.com/Microsoft/protool
 Description-Content-Type: text/markdown
 

{protool-2.0.0 → protool-3.0.0}/protool/__init__.py

@@ -12,10 +12,57 @@ import shutil
 import subprocess
 import sys
 import tempfile
-from typing import Any, cast, Dict, List, Optional
+from typing import Any, cast
 from OpenSSL import crypto
 
 
+def _extract_certificate_properties(cert: crypto.X509) -> dict[str, Any]:
+    """Extract key properties from an X509 certificate."""
+    subject = cert.get_subject()
+    issuer = cert.get_issuer()
+
+    # Helper to safely get X509Name components
+    def get_component(name_obj, component: str) -> str | None:
+        try:
+            return getattr(name_obj, component, None)
+        except AttributeError:
+            return None
+
+    # Parse ASN.1 TIME to ISO 8601 format
+    def parse_asn1_time(time_bytes: bytes | None) -> str | None:
+        if time_bytes is None:
+            return None
+        time_str = time_bytes.decode("utf-8")
+        # ASN.1 format: YYYYMMDDhhmmssZ
+        # Convert to ISO 8601: YYYY-MM-DDThh:mm:ssZ
+        try:
+            return f"{time_str[0:4]}-{time_str[4:6]}-{time_str[6:8]}T{time_str[8:10]}:{time_str[10:12]}:{time_str[12:14]}Z"
+        except (IndexError, ValueError):
+            return time_str  # Return as-is if parsing fails
+
+    return {
+        "CommonName": get_component(subject, "CN"),
+        "Organization": get_component(subject, "O"),
+        "OrganizationalUnit": get_component(subject, "OU"),
+        "Country": get_component(subject, "C"),
+        "IssuerCommonName": get_component(issuer, "CN"),
+        "IssuerOrganization": get_component(issuer, "O"),
+        "SerialNumber": str(
+            cert.get_serial_number()  # Other libs struggle with large integers
+        ),
+        "NotBefore": parse_asn1_time(cert.get_notBefore()),
+        "NotAfter": parse_asn1_time(cert.get_notAfter()),
+        "SignatureAlgorithm": (
+            cert.get_signature_algorithm().decode("utf-8")
+            if cert.get_signature_algorithm()
+            else None
+        ),
+        "Fingerprint": (
+            cert.digest("sha256").decode("utf-8") if hasattr(cert, "digest") else None
+        ),
+    }
+
+
 class ProvisioningType(Enum):
     """Enum representing the type of provisioning profile."""
 
@@ -32,22 +79,23 @@ class ProvisioningProfile:
     file_path: str
     file_name: str
     xml: str
-    _contents: Dict[str, Any]
-
-    app_id_name: Optional[str]
-    application_identifier_prefix: Optional[str]
-    creation_date: Optional[datetime.datetime]
-    platform: Optional[List[str]]
-    entitlements: Dict[str, Any]
-    expiration_date: Optional[datetime.datetime]
-    name: Optional[str]
-    team_identifier: Optional[List[str]]
-    team_name: Optional[str]
-    time_to_live: Optional[int]
-    uuid: Optional[str]
-    version: Optional[int]
-    provisioned_devices: Optional[List[str]]
-    provisions_all_devices: Optional[bool]
+    _contents: dict[str, Any]
+    _decode_certificates: bool
+
+    app_id_name: str | None
+    application_identifier_prefix: str | None
+    creation_date: datetime.datetime | None
+    platform: list[str] | None
+    entitlements: dict[str, Any]
+    expiration_date: datetime.datetime | None
+    name: str | None
+    team_identifier: list[str] | None
+    team_name: str | None
+    time_to_live: int | None
+    uuid: str | None
+    version: int | None
+    provisioned_devices: list[str] | None
+    provisions_all_devices: bool | None
 
     @property
     def profile_type(self) -> ProvisioningType:
@@ -66,24 +114,31 @@ class ProvisioningProfile:
 
         raise Exception("Unable to determine provisioning profile type")
 
-    def developer_certificates(self) -> List[crypto.X509]:
+    def developer_certificates(self) -> list[crypto.X509]:
         """Returns developer certificates as a list of PyOpenSSL X509."""
-        dev_certs: List[crypto.X509] = []
-        raw_cert_items: List[str] = cast(
-            List[str], self._contents.get("DeveloperCertificates", [])
+        dev_certs: list[crypto.X509] = []
+        raw_cert_items: list[bytes] = cast(
+            list[bytes], self._contents.get("DeveloperCertificates", [])
         )
 
         for cert_item in raw_cert_items:
             loaded_cert: crypto.X509 = crypto.load_certificate(
-                crypto.FILETYPE_ASN1, cert_item.encode()
+                crypto.FILETYPE_ASN1, cert_item
             )
             dev_certs.append(loaded_cert)
 
         return dev_certs
 
-    def __init__(self, file_path: str, *, sort_keys: bool = True) -> None:
+    def __init__(
+        self,
+        file_path: str,
+        *,
+        sort_keys: bool = True,
+        decode_certificates: bool = False,
+    ) -> None:
         self.file_path = os.path.abspath(file_path)
         self.file_name = os.path.basename(self.file_path)
+        self._decode_certificates = decode_certificates
         self.load_from_disk(sort_keys=sort_keys)
 
     def load_from_disk(self, *, sort_keys: bool = True) -> None:
@@ -96,7 +151,16 @@ class ProvisioningProfile:
 
         self._parse_contents()
 
-    def contents(self) -> Dict[str, Any]:
+        # If we decoded certificates, we need to regenerate the XML to include them
+        if self._decode_certificates:
+            contents_copy = copy.deepcopy(self._contents)
+            del contents_copy["DeveloperCertificates"]
+            del contents_copy["DER-Encoded-Profile"]
+            self.xml = plistlib.dumps(contents_copy, sort_keys=sort_keys).decode(
+                "utf-8"
+            )
+
+    def contents(self) -> dict[str, Any]:
         """Return a copy of the content dict."""
         return copy.deepcopy(self._contents)
 
@@ -119,6 +183,19 @@ class ProvisioningProfile:
         self.provisioned_devices = self._contents.get("ProvisionedDevices")
         self.provisions_all_devices = self._contents.get("ProvisionsAllDevices", False)
 
+        # Decode certificates if requested
+        if self._decode_certificates:
+            decoded_certs: list[dict[str, Any]] = []
+            for cert in self.developer_certificates():
+                try:
+                    decoded_certs.append(_extract_certificate_properties(cert))
+                except Exception as ex:
+                    # Log error but continue with other certificates
+                    print(
+                        f"Warning: Failed to decode certificate: {ex}", file=sys.stderr
+                    )
+            self._contents["DecodedDeveloperCertificates"] = decoded_certs
+
     def _get_xml(self) -> str:
         """Load the XML contents of a provisioning profile."""
         if not os.path.exists(self.file_path):
@@ -133,7 +210,7 @@ class ProvisioningProfile:
 # pylint: enable=too-many-instance-attributes
 
 
-def profiles(profiles_dir: Optional[str] = None) -> List[ProvisioningProfile]:
+def profiles(profiles_dir: str | None = None) -> list[ProvisioningProfile]:
     """Returns a list of all currently installed provisioning profiles."""
     if profiles_dir:
         dir_path = os.path.expanduser(profiles_dir)
@@ -143,7 +220,7 @@ def profiles(profiles_dir: Optional[str] = None) -> List[ProvisioningProfile]:
             user_path, "Library", "MobileDevice", "Provisioning Profiles"
         )
 
-    all_profiles = []
+    all_profiles: list[ProvisioningProfile] = []
     for profile in os.listdir(dir_path):
         full_path = os.path.join(dir_path, profile)
         _, ext = os.path.splitext(full_path)
@@ -159,8 +236,8 @@ def diff(
     b_path: str,
     *,
     sort_keys: bool = True,
-    ignore_keys: Optional[List[str]] = None,
-    tool_override: Optional[str] = None,
+    ignore_keys: list[str] | None = None,
+    tool_override: str | None = None,
 ) -> str:
     """Diff two provisioning profiles."""
 
@@ -223,7 +300,7 @@ def diff(
     return diff_contents
 
 
-def value_for_key(profile_path: str, key: str) -> Optional[Any]:
+def value_for_key(profile_path: str, key: str) -> Any | None:
     """Return the value for a given key"""
 
     profile = ProvisioningProfile(profile_path)
@@ -235,10 +312,10 @@ def value_for_key(profile_path: str, key: str) -> Optional[Any]:
         return None
 
 
-def decode(profile_path: str, xml: bool = True):
+def decode(profile_path: str, xml: bool = True, *, decode_certificates: bool = False):
     """Decode a profile, returning as a dictionary if xml is set to False."""
 
-    profile = ProvisioningProfile(profile_path)
+    profile = ProvisioningProfile(profile_path, decode_certificates=decode_certificates)
 
     if xml:
         return profile.xml

{protool-2.0.0 → protool-3.0.0}/protool/command_line.py

@@ -94,7 +94,9 @@ def _handle_read(args: argparse.Namespace) -> int:
 def _handle_decode(args: argparse.Namespace) -> int:
     """Handle the decode sub command."""
     try:
-        print(protool.decode(args.profile))
+        print(
+            protool.decode(args.profile, decode_certificates=args.decode_certificates)
+        )
     except Exception as ex:
         print(f"Could not decode: {ex}", file=sys.stderr)
         return 1
@@ -227,6 +229,15 @@ def _handle_arguments() -> int:
         help="The profile to read the value from",
     )
 
+    decode_parser.add_argument(
+        "-d",
+        "--decode-certificates",
+        dest="decode_certificates",
+        action="store_true",
+        default=False,
+        help="Decode and extract certificate properties",
+    )
+
     decode_parser.set_defaults(subcommand="decode")
 
     args = parser.parse_args()

{protool-2.0.0 → protool-3.0.0}/pyproject.toml

@@ -1,20 +1,25 @@
 [tool.poetry]
 name = "protool"
-version = "2.0.0"
+version = "3.0.0"
 description = "A tool for dealing with provisioning profiles"
 
 license = "MIT"
 
-authors = [
-    "Dale Myers <dalemy@microsoft.com>"
-]
+authors = ["Dale Myers <dalemy@microsoft.com>"]
 
 readme = 'README.md'
 
 repository = "https://github.com/Microsoft/protool"
 homepage = "https://github.com/Microsoft/protool"
 
-keywords = ['provisioning', 'profiles', 'apple', 'ios', 'xcode', 'mobileprovision']
+keywords = [
+    'provisioning',
+    'profiles',
+    'apple',
+    'ios',
+    'xcode',
+    'mobileprovision',
+]
 
 classifiers = [
     'Development Status :: 3 - Alpha',
@@ -27,23 +32,23 @@ classifiers = [
     'Programming Language :: Python :: 3.10',
     'Programming Language :: Python :: 3.11',
     'Topic :: Software Development',
-    'Topic :: Utilities'
+    'Topic :: Utilities',
 ]
 
 [tool.poetry.scripts]
 protool = 'protool:command_line.run'
 
 [tool.poetry.dependencies]
-python = "^3.8"
-pyOpenSSL ="^23.2.0"
+python = "^3.11"
+pyOpenSSL = "^25.1.0"
 
 [tool.poetry.dev-dependencies]
-black = "^23.7.0"
-mypy = "^1.4.1"
-pylint = "^2.17.5"
-pytest = "^7.4.0"
-pytest-cov = "^4.1.0"
-types-pyOpenSSL = "^23.2.0.2"
+black = "^26.1.0"
+mypy = "^1.19.1"
+pylint = "^4.0.4"
+pytest = "^9.0.2"
+pytest-cov = "^7.0.0"
+types-pyOpenSSL = "^24.1.0.20240722"
 
 [build-system]
 requires = ["poetry-core"]