c2pie 0.1.0a2__tar.gz

c2pie-0.1.0a2/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

c2pie-0.1.0a2/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: c2pie
+Version: 0.1.0a2
+Summary: The c2pie is a Python library that provides C2PA standard functionality.
+License-File: LICENSE
+Author: Tourmaline Core
+Author-email: contact@tourmalinecore.com
+Requires-Python: >=3.9.2,<3.15
+Classifier: Development Status :: 3 - Alpha
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: cbor2 (>=5.6.3,<6.0.0)
+Requires-Dist: cffi (<=2.0.0)
+Requires-Dist: cryptography (>=44.0.1)
+Requires-Dist: pypdf (>=6.1.1,<7.0.0)
+Requires-Dist: pytz (>=2024.1,<2025.0)
+Project-URL: Homepage, https://github.com/TourmalineCore/c2pie
+Project-URL: Issues, https://github.com/TourmalineCore/c2pie/issues

c2pie-0.1.0a2/c2pie/c2pa/assertion.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from typing import Any
+
+from c2pie.jumbf_boxes.content_box import ContentBox
+from c2pie.jumbf_boxes.super_box import SuperBox
+from c2pie.utils.assertion_schemas import (
+    C2PA_AssertionTypes,
+    cbor_to_bytes,
+    get_assertion_content_box_type,
+    get_assertion_content_type,
+    get_assertion_label,
+    json_to_bytes,
+)
+from c2pie.utils.content_types import jumbf_content_types
+
+
+class Assertion(SuperBox):
+    """Universal assertion superbox (one content box)."""
+
+    def __init__(
+        self,
+        assertion_type: C2PA_AssertionTypes,
+        schema: dict[str, Any],
+    ):
+        self.type = assertion_type
+        self.schema = schema
+
+        payload = self.get_payload_from_schema()
+        box_type_hex = get_assertion_content_box_type(self.type)
+        content_box = ContentBox(box_type=box_type_hex, payload=payload)
+
+        super().__init__(
+            content_type=get_assertion_content_type(self.type),
+            label=get_assertion_label(self.type),
+            content_boxes=[content_box],
+        )
+
+    def get_payload_from_schema(self) -> bytes:
+        ctype = get_assertion_content_type(self.type)
+        if ctype == jumbf_content_types["json"]:
+            return json_to_bytes(self.schema)
+        if ctype == jumbf_content_types["cbor"]:
+            return cbor_to_bytes(self.schema)
+        if ctype == jumbf_content_types["codestream"]:
+            return self.schema.get("payload", b"")
+        return b""
+
+    def get_data_for_signing(self) -> bytes:
+        return self.description_box.serialize() + self.serialize_content_boxes()
+
+
+class HashDataAssertion(Assertion):
+    """c2pa.hash.data hard binding assertion."""
+
+    def __init__(
+        self,
+        cai_offset: int,
+        hashed_data: bytes,
+        additional_exclusions: list[dict[str, int]] | None = None,
+    ):
+        exclusions: list[dict[str, int]] = [{"start": cai_offset, "length": 65535}]
+        if additional_exclusions:
+            exclusions.extend(additional_exclusions)
+
+        schema: dict[str, Any] = {
+            "name": "jumbf manifest",
+            "exclusions": exclusions,
+            "alg": "sha256",
+            "hash": hashed_data,
+            "pad": [],
+        }
+        super().__init__(C2PA_AssertionTypes.data_hash, schema)
+
+    def set_hash_data_length(self, length: int) -> None:
+        if self.schema.get("name") != "jumbf manifest":
+            raise ValueError("c2pa.hash.data: jumbf manifest is missing")
+        exclusions = self.schema.get("exclusions", [])
+        if not exclusions:
+            raise ValueError("c2pa.hash.data: exclusions are missing")
+        exclusions[0]["length"] = int(length)
+
+        payload = self.get_payload_from_schema()
+        if self.content_boxes:
+            self.content_boxes[0] = ContentBox(
+                box_type=get_assertion_content_box_type(self.type),
+                payload=payload,
+            )
+        else:
+            self.content_boxes = [
+                ContentBox(
+                    box_type=get_assertion_content_box_type(self.type),
+                    payload=payload,
+                )
+            ]
+        self.sync_payload()

c2pie-0.1.0a2/c2pie/c2pa/assertion_store.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from c2pie.jumbf_boxes.super_box import SuperBox
+from c2pie.utils.assertion_schemas import C2PA_AssertionTypes
+from c2pie.utils.content_types import c2pa_content_types
+
+
+class AssertionStore(SuperBox):
+    def __init__(
+        self,
+        assertions: list,
+    ):
+        self.assertions = assertions
+        super().__init__(
+            content_type=c2pa_content_types["assertions"],
+            label="c2pa.assertions",
+            content_boxes=self.assertions,
+        )
+
+    def get_assertions(self) -> list:
+        return self.assertions
+
+    def set_hash_data_length(
+        self,
+        length: int,
+    ) -> None:
+        for assertion in self.assertions:
+            if assertion.type == C2PA_AssertionTypes.data_hash:
+                assertion.set_hash_data_length(length)
+        self.sync_payload()

c2pie-0.1.0a2/c2pie/c2pa/claim.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import hashlib
+import uuid
+from typing import Any
+
+import cbor2
+
+from c2pie.c2pa.assertion_store import AssertionStore
+from c2pie.jumbf_boxes.content_box import ContentBox
+from c2pie.jumbf_boxes.super_box import SuperBox
+from c2pie.utils.content_types import c2pa_content_types
+
+
+def _sha256(b: bytes) -> bytes:
+    return hashlib.sha256(b).digest()
+
+
+class Claim(SuperBox):
+    """Claim (c2pa.claim) as a JUMBF superbox with one CBOR content box."""
+
+    def __init__(
+        self,
+        assertion_store: AssertionStore,
+        claim_generator: str = "c2pie",
+        manifest_label: str = f"urn:uuid:{uuid.uuid4().hex}",
+        dc_format: str = None,
+    ):
+        self.claim_generator = claim_generator
+        self.manifest_label = manifest_label
+        self.assertion_store = assertion_store
+        self.dc_format = dc_format
+
+        self.claim_signature_label = f"self#jumbf=c2pa/{self.manifest_label}/c2pa.signature"
+
+        self._instance_id = f"xmp:iid:{uuid.uuid4()}"
+
+        cbor_payload = self._build_cbor_payload()
+
+        content_box = ContentBox(
+            box_type=b"cbor".hex(),
+            payload=cbor_payload,
+        )
+        super().__init__(
+            content_type=c2pa_content_types["claim"],
+            label="c2pa.claim",
+            content_boxes=[content_box],
+        )
+
+    def get_cbor_payload(self) -> bytes:
+        """CBOR bytes, on top of which COSE (detached) is signed."""
+        return self.content_boxes[0].get_payload()
+
+    def get_manifest_label(self) -> str:
+        return self.manifest_label
+
+    def set_assertion_store(self, assertion_store) -> None:
+        """
+        Called from Manifest when assertions are changed (including when length is updated in c2pa.hash.data).
+        Reassemble the CBOR payload of the stamp with the correct hashed URIs.
+        """
+        self.assertion_store = assertion_store
+        self._rebuild_payload()
+
+    def set_format(self, dc_format: str | None) -> None:
+        self.dc_format = dc_format
+        self._rebuild_payload()
+
+    def _build_assertions_array(self) -> list[dict[str, Any]]:
+        """
+        Build the claim[‘assertions’] array from the current AssertionStore:
+          - url:  self#jumbf=/c2pa/<manifest_label>/c2pa.assertions/<label>
+          - alg:  sha256
+          - hash: sha256( JUMBF-superbox-content = description + content_boxes ) for this assertion
+        """
+        out: list[dict[str, Any]] = []
+        if not self.assertion_store:
+            return out
+
+        assertions = getattr(self.assertion_store, "assertions", None)
+        if assertions is None and hasattr(self.assertion_store, "get_assertions"):
+            assertions = self.assertion_store.get_assertions()
+        if not assertions:
+            return out
+
+        for assertion in assertions:
+            label = getattr(assertion, "label", None)
+            if label is None and hasattr(assertion, "get_label"):
+                label = assertion.get_label()
+
+            if hasattr(assertion, "get_data_for_signing"):
+                data = assertion.get_data_for_signing()
+            else:
+                data = assertion.description_box.serialize() + assertion.serialize_content_boxes()
+
+            out.append(
+                {
+                    "url": f"self#jumbf=/c2pa/{self.manifest_label}/c2pa.assertions/{label}",
+                    "alg": "sha256",
+                    "hash": _sha256(data),
+                }
+            )
+        return out
+
+    def _build_cbor_payload(self) -> bytes:
+        """
+        Canonical CBOR content claim.
+        Include:
+          - claim_generator
+          - instanceID (stable for the object)
+          - signature (reference to c2pa.signature)
+          - optional dc:format
+          - optional assertions (if there is an assertion_store)
+        """
+        claim: dict[str, Any] = {
+            "claim_generator": self.claim_generator,
+            "instanceID": self._instance_id,
+            "signature": self.claim_signature_label,
+            "alg": "sha256",
+        }
+        if self.dc_format:
+            claim["dc:format"] = self.dc_format
+
+        assertions_arr = self._build_assertions_array()
+        if assertions_arr:
+            claim["assertions"] = assertions_arr
+
+        return cbor2.dumps(claim, canonical=True)
+
+    def _rebuild_payload(self) -> None:
+        new_payload = self._build_cbor_payload()
+        self.content_boxes[0] = ContentBox(
+            box_type=b"cbor".hex(),
+            payload=new_payload,
+        )
+        self.sync_payload()

c2pie-0.1.0a2/c2pie/c2pa/claim_signature.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+import cbor2
+from cryptography import x509
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.hazmat.primitives.serialization import Encoding
+
+from c2pie.c2pa.claim import Claim
+from c2pie.jumbf_boxes.content_box import ContentBox
+from c2pie.jumbf_boxes.super_box import SuperBox
+from c2pie.utils.content_types import c2pa_content_types
+
+
+def _split_pem_certs_to_der(pem_bytes: bytes) -> list[bytes]:
+    if not pem_bytes:
+        return []
+    blocks = re.findall(
+        b"-----BEGIN CERTIFICATE-----\\s.*?-----END CERTIFICATE-----\\s*",
+        pem_bytes,
+        flags=re.DOTALL,
+    )
+    ders: list[bytes] = []
+    for blk in blocks:
+        cert = x509.load_pem_x509_certificate(blk)
+        ders.append(cert.public_bytes(Encoding.DER))
+    return ders
+
+
+class ClaimSignature(SuperBox):
+    """
+    COSE_Sign1 (PS256), detached:
+      - protected: {1:-37, 33:[x5chain DER...]}
+      - unprotected: {}
+      - COSE payload = nil
+      - Sig_structure payload = bstr(Claim CBOR)
+    """
+
+    def __init__(
+        self,
+        claim: Claim,
+        *,
+        private_key: bytes,
+        certificate_pem_bundle: bytes = None,
+        certificate: bytes = None,
+    ):
+        if certificate_pem_bundle is None and certificate is not None:
+            certificate_pem_bundle = certificate
+
+        self.claim = claim
+        self.private_key = private_key
+        self.certificate = certificate_pem_bundle
+
+        content_boxes = self._generate_payload()
+        super().__init__(
+            content_type=c2pa_content_types["claim_signature"],
+            label="c2pa.signature",
+            content_boxes=content_boxes,
+        )
+
+    def _generate_payload(self) -> list[ContentBox]:
+        if not (self.claim and self.private_key and self.certificate):
+            return []
+
+        cose_tagged = self._create_cose_sign1()
+        return [ContentBox(box_type=b"cbor".hex(), payload=cose_tagged)]
+
+    def set_claim(self, claim: Claim):
+        self.claim = claim
+        content_boxes = self._generate_payload()
+        super().__init__(
+            content_type=c2pa_content_types["claim_signature"],
+            label="c2pa.signature",
+            content_boxes=content_boxes,
+        )
+
+    def _generate_protected_header(self) -> bytes:
+        der_chain = _split_pem_certs_to_der(self.certificate or b"")
+        protected: dict[int, Any] = {1: -37}
+        if der_chain:
+            protected[33] = der_chain
+        return cbor2.dumps(protected, canonical=True)
+
+    def _create_cose_sign1(self) -> bytes:
+        phdr_serialized = self._generate_protected_header()
+        claim_cbor = self.claim.get_cbor_payload()
+        sig_structure = ["Signature1", phdr_serialized, b"", claim_cbor]
+        to_sign = cbor2.dumps(sig_structure, canonical=True)
+
+        key = serialization.load_pem_private_key(self.private_key, password=None)
+        signature = key.sign(  # type: ignore
+            to_sign,
+            padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=32),  # type: ignore
+            hashes.SHA256(),  # type: ignore
+        )
+
+        cose_msg = [phdr_serialized, {}, None, signature]
+        return cbor2.dumps(cbor2.CBORTag(18, cose_msg), canonical=True)

c2pie-0.1.0a2/c2pie/c2pa/config.py

@@ -0,0 +1 @@
+RETRY_SIGNATURE = 8  # max retries, might be terminated earliers

c2pie-0.1.0a2/c2pie/c2pa/manifest.py

@@ -0,0 +1,56 @@
+import uuid
+
+from c2pie.jumbf_boxes.super_box import SuperBox
+from c2pie.utils.content_types import c2pa_content_types
+
+
+class Manifest(SuperBox):
+    """
+    C2PA Manifest: Assertion Store + Claim + Claim Signature.
+    The manifest label is compatible with c2patool: urn:uuid:<uuid-hex>
+    """
+
+    def __init__(
+        self,
+        manifest_label: str = f"urn:uuid:{uuid.uuid4().hex}",
+    ):
+        self.manifest_label = manifest_label
+        self.claim = None
+        self.claim_signature = None
+        self.assertion_store = None
+
+        super().__init__(content_type=c2pa_content_types["default_manifest"], label=self.manifest_label)
+
+    def set_claim(self, claim):
+        self.claim = claim
+        self.add_content_box(self.claim)
+
+    def set_claim_signature(self, claim_signature):
+        self.claim_signature = claim_signature
+        self.add_content_box(self.claim_signature)
+
+    def set_assertion_store(self, assertion_store):
+        self.assertion_store = assertion_store
+        self.add_content_box(self.assertion_store)
+
+    def get_manifest_label(self):
+        return self.manifest_label
+
+    def get_assertions(self):
+        if self.assertion_store:
+            return self.assertion_store.get_assertions()
+        return
+
+    def set_hash_data_length(self, length: int):
+        """
+        Updates the length of exceptions in HashData, reassembles Claim (assertion hashes)
+        and ClaimSignature (COSE Sign1 detached over Claim CBOR).
+        """
+        if self.assertion_store and self.claim and self.claim_signature:
+            self.assertion_store.set_hash_data_length(length)
+
+            self.claim.set_assertion_store(self.assertion_store)
+
+            self.claim_signature.set_claim(self.claim)
+
+        self.sync_payload()