amd-ucode-patch 1.0.0__tar.gz → 1.1.0__tar.gz

{amd_ucode_patch-1.0.0 → amd_ucode_patch-1.1.0}/.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4
+      uses: github/codeql-action/init@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # v4
       with:
         languages: ${{ matrix.language }}
         build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
         exit 1
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4
+      uses: github/codeql-action/analyze@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # v4
       with:
         category: "/language:${{matrix.language}}"

{amd_ucode_patch-1.0.0 → amd_ucode_patch-1.1.0}/.github/workflows/scorecard.yml

@@ -38,6 +38,6 @@ jobs:
           retention-days: 5
 
       - name: Upload to code-scanning
-        uses: github/codeql-action/upload-sarif@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
+        uses: github/codeql-action/upload-sarif@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # v4.37.0
         with:
           sarif_file: results.sarif

{amd_ucode_patch-1.0.0 → amd_ucode_patch-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amd-ucode-patch
-Version: 1.0.0
+Version: 1.1.0
 Summary: A Python library for parsing and interpreting AMD microcode patch files
 Project-URL: Homepage, https://github.com/amd-zenith/amd-ucode-patch
 Project-URL: Repository, https://github.com/amd-zenith/amd-ucode-patch
@@ -23,7 +23,9 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Hardware
 Classifier: Topic :: Utilities
 Requires-Python: >=3.10
-Requires-Dist: rich
+Requires-Dist: amd-cpuid==1.0.1
+Requires-Dist: pycryptodome==3.23.0
+Requires-Dist: rich==15.0.0
 Description-Content-Type: text/markdown
 
 # AMD Microcode Patch

{amd_ucode_patch-1.0.0 → amd_ucode_patch-1.1.0}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling", "hatch-vcs"]
+requires = ["hatchling==1.31.0", "hatch-vcs==0.5.0"]
 build-backend = "hatchling.build"
 
 [project]
@@ -30,7 +30,9 @@ classifiers = [
     "Topic :: Utilities",
 ]
 dependencies = [
-  "rich",
+  "amd-cpuid==1.0.1",
+  "pycryptodome==3.23.0",
+  "rich==15.0.0",
 ]
 
 [project.urls]
@@ -39,7 +41,8 @@ Repository = "https://github.com/amd-zenith/amd-ucode-patch"
 Issues = "https://github.com/amd-zenith/amd-ucode-patch/issues"
 
 [project.scripts]
-amd_ucode_patch_info = "amd_ucode_patch.cli_info:main"
+amd_ucode_patch_info = "amd_ucode_patch.cli.info:main"
+amd_ucode_patch_sign = "amd_ucode_patch.cli.sign:main"
 
 [tool.hatch.version]
 source = "vcs"

amd_ucode_patch-1.1.0/src/amd_ucode_patch/cli/argtypes.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+"""
+Argparse ``type=`` converters for hex-encoded key material shared by the
+command line tools. Each raises ``argparse.ArgumentTypeError`` on malformed or
+wrong-length input, which argparse renders as a usage error.
+"""
+
+import argparse
+
+
+def parse_fixed_hex(value: str, nbytes: int, what: str) -> bytes:
+    """
+    Parse ``value`` as hex (an optional ``0x`` prefix is allowed) and require it
+    to decode to exactly ``nbytes`` bytes. ``what`` names the field in error
+    messages.
+    """
+    text = value.strip().lower()
+    if text.startswith("0x"):
+        text = text[2:]
+    try:
+        data = bytes.fromhex(text)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"{what} must be hexadecimal, got {value!r}")
+    if len(data) != nbytes:
+        raise argparse.ArgumentTypeError(f"{what} must be {nbytes} bytes ({2 * nbytes} hex chars), got {len(data)}")
+    return data
+
+
+def parse_key(value: str) -> bytes:
+    """Parse a 16-byte AES-128 CMAC key from hex."""
+    return parse_fixed_hex(value, 16, "key")
+
+
+def parse_modulus(value: str) -> bytes:
+    """Parse a 256-byte RSA modulus from hex."""
+    return parse_fixed_hex(value, 256, "modulus")
+
+
+def parse_private(value: str) -> bytes:
+    """Parse a 256-byte RSA private exponent from hex."""
+    return parse_fixed_hex(value, 256, "private exponent")
+
+
+def parse_check(value: str) -> bytes:
+    """Parse a 256-byte signature check (Montgomery helper) field from hex."""
+    return parse_fixed_hex(value, 256, "check")

amd_ucode_patch-1.0.0/src/amd_ucode_patch/cli_info.py → amd_ucode_patch-1.1.0/src/amd_ucode_patch/cli/info.py

@@ -4,42 +4,41 @@
 A command line tool to print information about AMD uCode patch files.
 '''
 
-import glob
 import argparse
-from pathlib import Path
 from rich import box
 from rich.console import Console
 from rich.table import Table
-from .banner import BANNER
-from .parse import ucode_patch_parse
+from amd_ucode_patch.cli.banner import BANNER
+from amd_ucode_patch.cli.paths import expand_paths
+from amd_ucode_patch.parse import ucode_patch_parse
+from amd_ucode_patch.structures.patch_level import PatchLevelV2
 
-COLS = ["File", "Date", "Upd. Rev", "Loader ID", "Proc. Rev", "CPUID", "Family", "Model", "Stepping", "Autorun", "Encrypted", "Body size"]
-
-
-def expand_paths(patterns):
-    for pattern in patterns:
-        matches = sorted(glob.glob(pattern, recursive=True))
-        if not matches:
-            yield Path(pattern)
-            continue
-        for match in matches:
-            yield Path(match)
+COLS = ["File", "Date", "Patch level", "PL Ver", "PL Rev", "Loader ID", "Proc. Rev", "CPUID", "Family", "Family Name", "Model", "Stepping", "Microarch", "Codename", "Signed", "Autorun", "Encrypted", "Body size"]
 
 
 def _row_fields(path, patch):
+    patch_level = patch.header.patch_level
+    # Advanced (v2 / Zen+) patch level fields are only meaningful when present.
+    patch_rev = f"{patch_level.rev:02x}" if isinstance(patch_level, PatchLevelV2) else ""
     return (
         str(path),
-        f"{patch.header.year:04d}-{patch.header.month:02d}-{patch.header.day:02d}",
-        f"{patch.header.update_revision:08x}",
+        str(patch.header.date),
+        str(patch_level),
+        f"v{int(patch_level.version)}",
+        patch_rev,
         f"{patch.header.loader_id:04x}",
-        f"{patch.header.processor_rev_id:04x}",
-        patch.header.cpuid_str,
-        f"0x{patch.header.cpu_family:02x}",
-        f"0x{patch.header.cpu_model:02x}",
-        f"0x{patch.header.cpu_stepping:02x}",
-        f"{patch.verified_header.autorun if patch.verified_header is not None else ''}",
-        f"{patch.verified_header.encrypted if patch.verified_header is not None else ''}",
-        f"{len(patch.body)}",
+        f"{patch.header.cpuid.ucode_signature:04x}",
+        f"{patch.header.cpuid.cpuid_signature:08X}",
+        f"0x{patch.header.cpuid.family:02x}",
+        patch.header.cpuid.familyname,
+        f"0x{patch.header.cpuid.model:02x}",
+        f"0x{patch.header.cpuid.stepping:02x}",
+        patch.header.cpuid.microarchitecture,
+        patch.header.cpuid.codename,
+        "yes" if patch.header.signature is not None else "no",
+        f"{patch.body.verified_header.autorun if patch.body.verified_header is not None else ''}",
+        f"{patch.body.verified_header.encrypted if patch.body.verified_header is not None else ''}",
+        f"{len(patch.body.data)}",
     )
 
 def print_table(console: Console, paths, format):

amd_ucode_patch-1.1.0/src/amd_ucode_patch/cli/paths.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+"""Shared path handling for the command line tools."""
+
+import glob
+from pathlib import Path
+from collections.abc import Iterable, Iterator
+
+
+def expand_paths(patterns: Iterable[str]) -> Iterator[Path]:
+    """
+    Expand each glob pattern into the matching paths (sorted, recursive ``**``
+    supported). A pattern with no matches is yielded verbatim as a ``Path`` so the
+    caller can surface a sensible "file not found" error.
+    """
+    for pattern in patterns:
+        matches = sorted(glob.glob(pattern, recursive=True))
+        if not matches:
+            yield Path(pattern)
+            continue
+        for match in matches:
+            yield Path(match)

amd_ucode_patch-1.1.0/src/amd_ucode_patch/cli/sign.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: GPL-2.0-or-later
+'''
+A command line tool to inspect, verify, sign and resign AMD uCode patches.
+'''
+
+import sys
+import argparse
+from pathlib import Path
+from rich import box
+from rich.console import Console
+from rich.table import Table
+from amd_ucode_patch.cli.banner import BANNER
+from amd_ucode_patch.parse import ucode_patch_parse
+from amd_ucode_patch.utils.cmac import cmac_digest
+from amd_ucode_patch.utils.entrysign import produce_colliding_key
+from amd_ucode_patch.utils.rsa import montgomery_n_prime, sign_pkcs1_v15_payload
+from amd_ucode_patch.cli.paths import expand_paths
+from amd_ucode_patch.cli.argtypes import parse_key, parse_modulus, parse_private
+
+
+COLS = ["File", "Signed", "Digest", "Valid"]
+
+
+def _verify_row(path, key):
+    """Return the four display cells (File, Signed, Digest, Valid) for one patch."""
+    patch = ucode_patch_parse(path)
+    signature = patch.header.signature
+
+    if signature is None:
+        return (str(path), "[yellow]no[/yellow]", "", "[dim]n/a[/dim]")
+
+    recovered = signature.recover_digest()
+    digest = recovered.hex() if recovered is not None else "[red]<bad padding>[/red]"
+
+    if key is None:
+        return (str(path), "[green]yes[/green]", digest, "[dim]not checked[/dim]")
+
+    computed = cmac_digest(patch.body.to_bytes(), key)
+    verdict = recovered is not None and recovered == computed
+    valid = "[green]yes[/green]" if verdict else "[red]no[/red]"
+    return (str(path), "[green]yes[/green]", digest, valid)
+
+
+def verify(args, console):
+    """Process the ``verify`` command: print a signature table for each file."""
+    table = Table(*COLS, box=box.HEAVY_HEAD)
+    for path in expand_paths(args.files):
+        try:
+            row = _verify_row(path, args.key)
+            table.add_row(*row)
+        except Exception as e:
+            console.log(f"Error reading {path}: {e}")
+    console.print(table)
+
+
+def _write_target(src: Path, output: Path | None) -> Path:
+    return output if output is not None else src
+
+
+def _resign_one(
+    path: Path,
+    key: bytes,
+    private: bytes | None,
+    modulus: bytes | None,
+    output: Path | None,
+) -> tuple[Path, str]:
+    patch = ucode_patch_parse(path)
+    signature = patch.header.signature
+    if signature is None:
+        raise ValueError("patch is unsigned (pre-Zen), cannot resign")
+
+    digest = cmac_digest(patch.body.to_bytes(), key)
+    if private is None:
+        target = cmac_digest(signature.modulus, key)
+        new_modulus, new_private = produce_colliding_key(target, cmac_key=key)
+    else:
+        new_modulus = modulus if modulus is not None else signature.modulus
+        new_private = private
+
+    signature.modulus = new_modulus
+    signature.check = montgomery_n_prime(new_modulus)
+    signature.signature = sign_pkcs1_v15_payload(digest, new_modulus, new_private)
+
+    out_path = _write_target(path, output)
+    out_path.write_bytes(patch.to_bytes())
+    return out_path, digest.hex()
+
+
+def resign(args, console) -> int:
+    """
+    Process the ``resign`` command: re-sign edited patches, in place by default.
+    Returns a process exit code (non-zero if any file failed or the arguments
+    were invalid).
+    """
+    if args.output is not None and len(args.files) != 1:
+        console.log("Error: --output is only allowed with a single input file")
+        return 1
+    if args.modulus is not None and args.private is None:
+        console.log("Error: --modulus requires --private")
+        return 1
+
+    exit_code = 0
+    for path in expand_paths(args.files):
+        try:
+            target, digest = _resign_one(
+                path,
+                args.key,
+                args.private,
+                args.modulus,
+                args.output,
+            )
+            console.print(f"[green]resigned[/green] {target} digest={digest}")
+        except Exception as e:
+            console.log(f"Error resigning {path}: {e}")
+            exit_code = 1
+    return exit_code
+
+
+def main():
+    console = Console()
+    console.print(BANNER, highlight=False)
+
+    parser = argparse.ArgumentParser(
+        description="Inspect, verify, sign and resign AMD microcode patch signatures.",
+        epilog="The published Zen 1-4 CMAC key is 2b7e151628aed2a6abf7158809cf4f3c.",
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    verify_parser = subparsers.add_parser("verify", help="Inspect signatures and verify with -k when provided")
+    verify_parser.add_argument("files", nargs="+", help="Patch files to inspect")
+    verify_parser.add_argument("-k", "--key", type=parse_key, default=None, help="AES-128 CMAC key as hex (32 hex chars); enables verification")
+
+    resign_parser = subparsers.add_parser("resign", help="Re-sign edited patches in-place (zentool-style)")
+    resign_parser.add_argument("files", nargs="+", help="Patch files to resign")
+    resign_parser.add_argument("-k", "--key", type=parse_key, required=True, help="AES-128 CMAC key as hex (default: published Zen 1-4 key)")
+    resign_parser.add_argument("-d", "--private", type=parse_private, default=None, help="RSA private exponent as 512 hex chars (256 bytes). Optional.")
+    resign_parser.add_argument("-m", "--modulus", type=parse_modulus, default=None, help="RSA modulus as 512 hex chars (256 bytes). Used with --private.")
+    resign_parser.add_argument("-o", "--output", type=Path, default=None, help="Output file (single-input only). Defaults to in-place rewrite")
+
+    args = parser.parse_args()
+
+    if args.command == "verify":
+        verify(args, console)
+    elif args.command == "resign":
+        sys.exit(resign(args, console))
+    else:
+        console.log(f"Error: unknown command {args.command!r}")
+
+
+if __name__ == "__main__":
+    main()

amd_ucode_patch-1.1.0/src/amd_ucode_patch/naming.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+from .structures.patch import Patch
+
+def ucode_patch_name(patch: Patch, enc_override=None) -> str:
+    # Format should be:
+    # family<family>_cpuid<cpuid>_rev<revision>_date<yyyymmdd>_enc<ee>_sha<hash12>.bin
+    # The _enc<ee> suffix is only present when a verified header exists.
+    cpuid = patch.header.cpuid
+    name = f"family{cpuid.family:02x}_cpuid{cpuid.cpuid_signature:08X}_rev{patch.header.patch_level}_date{patch.header.date.year:04}{patch.header.date.month:02}{patch.header.date.day:02}"
+    if patch.body.verified_header is not None:
+        enc = patch.body.verified_header.encrypted if enc_override is None else enc_override
+        name += f"_enc{enc:02}"
+    hash12 = patch.sha256_hex()[:12]
+    name += f"_sha{hash12}"
+    name += ".bin"
+    return name

amd_ucode_patch-1.1.0/src/amd_ucode_patch/parse.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+from pathlib import Path
+from .structures.patch import Patch
+
+def ucode_patch_parse(file: Path) -> Patch:
+    with file.open("rb") as f:
+        return Patch.from_bytes(f.read())

amd_ucode_patch-1.1.0/src/amd_ucode_patch/structures/body.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+from dataclasses import dataclass
+from .verified_header import VerifiedHeader
+
+
+#: Family at/after which the body carries a verified header (options + rev).
+#: This is the Zen boundary; kept independent of the signature gating.
+VERIFIED_HEADER_MIN_FAMILY = 0x17
+
+
+@dataclass
+class Body:
+    """
+    The signed portion of an AMD microcode patch -- the region the RSA signature
+    in :class:`PatchHeader` covers (through the AES-CMAC).
+
+    On Zen (signed) patches it is the ``options``/``rev`` block
+    (:class:`VerifiedHeader`) followed by the match registers and the (encrypted)
+    microcode opquads. On pre-Zen patches there is no verified header and the
+    whole thing is the raw, unsigned microcode.
+    """
+
+    verified_header: VerifiedHeader | None
+    data: bytes
+
+    @staticmethod
+    def from_bytes(buf: bytes, family: int | None = None) -> "Body":
+        """
+        Parse the body. The verified header (options + rev) is present only on
+        Zen patches (family >= ``VERIFIED_HEADER_MIN_FAMILY``); ``family`` selects
+        that. When ``family`` is unknown the body is treated as having none.
+        """
+        if family is not None and family >= VERIFIED_HEADER_MIN_FAMILY:
+            verified_header = VerifiedHeader.from_bytes(buf, family=family)
+            data = buf[VerifiedHeader.SIZE:]
+        else:
+            verified_header = None
+            data = buf
+        return Body(verified_header=verified_header, data=data)
+
+    def to_bytes(self) -> bytes:
+        prefix = self.verified_header.to_bytes() if self.verified_header is not None else b""
+        return prefix + self.data

amd_ucode_patch-1.1.0/src/amd_ucode_patch/structures/patch.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+import hashlib
+from dataclasses import dataclass
+from .patch_header import PatchHeader
+from .body import Body
+
+
+@dataclass
+class Patch:
+    header: PatchHeader
+    body: Body
+
+
+    @staticmethod
+    def from_bytes(buf: bytes) -> "Patch":
+        header = PatchHeader.from_bytes(buf)
+        # Everything after the header is the signed body: the verified header
+        # (options + rev, Zen only) plus the microcode itself.
+        body = Body.from_bytes(buf[header.size:], family=header.cpuid.family)
+        return Patch(header=header, body=body)
+
+    def to_bytes(self) -> bytes:
+        """The whole patch encoding: the header (with signature block, if any)
+        followed by the signed body."""
+        return self.header.to_bytes() + self.body.to_bytes()
+
+    def signature_verifies(self, cmac_key: bytes) -> bool | None:
+        """
+        Whether the patch signature verifies against its embedded public key,
+        using the provided CMAC key (see :data:`Signature.verify`).
+
+        ``None`` for unsigned (pre-Zen) patches. A ``False`` result does not by
+        itself mean the patch is forged: patches signed with a CMAC key this
+        library does not ship -- Zen 5, and AMD's post-EntrySign patches that
+        rotated the key -- also report ``False`` even though their RSA signature
+        is structurally valid against the embedded modulus.
+        """
+        if self.header.signature is None:
+            return None
+        return self.header.signature.verify(self.body.to_bytes(), cmac_key)
+
+    def sha256(self) -> bytes:
+        """SHA-256 digest of the whole patch (header + body)."""
+        return hashlib.sha256(self.to_bytes()).digest()
+
+    def sha256_hex(self) -> str:
+        """SHA-256 digest of the whole patch (header + body) as a hex string."""
+        return hashlib.sha256(self.to_bytes()).hexdigest()

amd_ucode_patch-1.1.0/src/amd_ucode_patch/structures/patch_date.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+import struct
+from dataclasses import dataclass
+
+from amd_ucode_patch.utils.bcd import decode_bcd, encode_bcd, is_bcd
+
+
+@dataclass
+class PatchDate:
+    """
+    Build date stored in the first 32-bit word of an AMD microcode patch header.
+
+    The field is a little-endian, packed binary-coded-decimal value laid out as
+    0xMMDDYYYY: the high byte holds the month, the next byte the day, and the low
+    16 bits the four-digit year (e.g. 0x12282021 decodes to 2021-12-28).
+    """
+
+    FMT = "<HBB"  # year (u16), day (u8), month (u8)
+    SIZE = struct.calcsize(FMT)
+
+    YEAR_NIBBLES = 4
+    DAY_NIBBLES = 2
+    MONTH_NIBBLES = 2
+    NIBBLE_COUNT = YEAR_NIBBLES + DAY_NIBBLES + MONTH_NIBBLES
+
+    # Loose calendar bounds, used only to reject obviously bogus values when
+    # probing a file.
+    MIN_YEAR = 1990
+    MAX_YEAR = 2099
+
+    # Known AMD patches that ship an out-of-range date but are otherwise
+    # legitimate. Treated as plausible despite failing the calendar checks.
+    # 2011-13-09 -> family12_cpuid00300F10_rev03000027 (month 13).
+    KNOWN_EXCEPTIONS = frozenset({(2011, 13, 9)})
+
+    year: int
+    month: int
+    day: int
+
+    @staticmethod
+    def from_bytes(buf: bytes) -> "PatchDate":
+        if len(buf) < PatchDate.SIZE:
+            raise ValueError("not enough bytes for AMD patch date")
+        raw_year, raw_day, raw_month = struct.unpack(PatchDate.FMT, buf[0:PatchDate.SIZE])
+        return PatchDate(
+            year=decode_bcd(raw_year, PatchDate.YEAR_NIBBLES),
+            day=decode_bcd(raw_day, PatchDate.DAY_NIBBLES),
+            month=decode_bcd(raw_month, PatchDate.MONTH_NIBBLES),
+        )
+
+    def to_bytes(self) -> bytes:
+        return struct.pack(
+            PatchDate.FMT,
+            encode_bcd(self.year, PatchDate.YEAR_NIBBLES),
+            encode_bcd(self.day, PatchDate.DAY_NIBBLES),
+            encode_bcd(self.month, PatchDate.MONTH_NIBBLES),
+        )
+
+    @staticmethod
+    def is_valid_encoding(buf: bytes) -> bool:
+        """
+        Return ``True`` if ``buf`` holds well-formed packed BCD that decodes to a
+        plausible calendar date. Intended as a lightweight signature check while
+        deciding whether a file looks like a microcode patch.
+        """
+        if len(buf) < PatchDate.SIZE:
+            return False
+        raw_year, raw_day, raw_month = struct.unpack(PatchDate.FMT, buf[0:PatchDate.SIZE])
+        if not (
+            is_bcd(raw_year, PatchDate.YEAR_NIBBLES)
+            and is_bcd(raw_day, PatchDate.DAY_NIBBLES)
+            and is_bcd(raw_month, PatchDate.MONTH_NIBBLES)
+        ):
+            return False
+        return PatchDate.from_bytes(buf).is_plausible()
+
+    def is_plausible(self) -> bool:
+        """Return ``True`` if the components fall within sane calendar ranges."""
+        if (self.year, self.month, self.day) in PatchDate.KNOWN_EXCEPTIONS:
+            return True
+        return (
+            1 <= self.month <= 12
+            and 1 <= self.day <= 31
+            and PatchDate.MIN_YEAR <= self.year <= PatchDate.MAX_YEAR
+        )
+
+    def __str__(self) -> str:
+        return f"{self.year:04d}-{self.month:02d}-{self.day:02d}"