Merge branch 'main' into f/hehehe

Author: achamayou

.gitignore

@@ -45,4 +45,5 @@ tests/perf-system/analyzer/*.png
 **/*.ipynb*
 scripts/azure_deployment/.env
 .env
-python/src/ccf/version.py
+python/src/ccf/version.py
+scripts/env-*

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Added
 
+- Backup nodes can now be configured to automatically fetch snapshots from the primary when snapshot evidence is detected. This is controlled by the `snapshots.backup_fetch` configuration section, with `enabled`, `max_attempts`, `retry_interval`, `max_size` and `target_rpc_interface` options. Note that the target RPC interface selected must have the `SnapshotRead` operator feature enabled.
 - Added `ccf::IdentityHistoryNotFetched` exception type to distinguish identity-history-fetching errors from other logic errors in the network identity subsystem (#7708).
 - Added `ccf::describe_cose_receipt_v1(receipt)` to obtain COSE receipts with Merkle proof in unprotected header for non-signature TXs, and empty unprotected header for signature TXs (#7700).
 - `NetworkIdentitySubsystemInterface` now exposes `get_trusted_keys()`, returning all trusted network identity keys as a `TrustedKeys` map (#7690).
@@ -19,10 +20,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ### Changed
 
 - On recovery, the UVM descriptor SVN is now set to the minimum of the previously stored value in the KV and the value found in the new node's startup endorsements. On start, the behaviour is unchanged (#7716).
-- Refactored the user facing surface of self-healing-open and local sealing. The whole feature is now `sealing-recovery` with `self-healing-open` now referred to as the `recovery-decision-protocol`. (#7679)
-  - Local sealing is enabled by setting the `sealing-recovery` config field (for both the sealing node, and the unsealing recovery node)
-  - The local sealing identity is under `sealing-recovery.location.name`
-  - The recovery-decision-protocol is configured via `sealing-recovery.recovery_decision_protocol`
+- Refactored the user facing surface of self-healing-open and local sealing. The whole feature is now `sealing-recovery` with `self-healing-open` now referred to as the `recovery-decision-protocol` (#7679).
+  - Local sealing is enabled by setting the `sealing-recovery` config field (for both the sealing node, and the unsealing recovery node).
+  - The local sealing identity is under `sealing-recovery.location.name`.
+  - The recovery-decision-protocol is configured via `sealing-recovery.recovery_decision_protocol`.
+- Snapshots now carry COSE receipts, JSON receipts are no longer included (#7711).
 
 ## [7.0.0-dev11]
 

doc/host_config_schema/cchost_config.json

@@ -498,6 +498,39 @@
         "read_only_directory": {
           "type": ["string", "null"],
           "description": "Path to read-only snapshots directory"
+        },
+        "backup_fetch": {
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "default": false,
+              "description": "If true, backup nodes will automatically fetch snapshots from the primary when snapshot evidence is detected"
+            },
+            "max_attempts": {
+              "type": "integer",
+              "default": 3,
+              "description": "Maximum number of fetch attempts before giving up",
+              "minimum": 1
+            },
+            "retry_interval": {
+              "type": "string",
+              "default": "1000ms",
+              "description": "Delay between retry attempts"
+            },
+            "target_rpc_interface": {
+              "type": "string",
+              "default": "primary_rpc_interface",
+              "description": "Name of the RPC interface on the primary node to use for downloading snapshots. Must have the SnapshotRead feature enabled."
+            },
+            "max_size": {
+              "type": "string",
+              "default": "200MB",
+              "description": "Maximum size of snapshot this node is willing to fetch"
+            }
+          },
+          "description": "Configuration for automatic snapshot fetching by backup nodes",
+          "additionalProperties": false
         }
       },
       "description": "This section includes configuration for the snapshot directories and files",

include/ccf/node/startup_config.h

@@ -99,6 +99,18 @@ namespace ccf
       size_t tx_count = 10'000;
       std::optional<std::string> read_only_directory = std::nullopt;
 
+      struct BackupFetch
+      {
+        bool enabled = false;
+        size_t max_attempts = 3;
+        ccf::ds::TimeString retry_interval = {"1000ms"};
+        std::string target_rpc_interface = ccf::PRIMARY_RPC_INTERFACE;
+        ccf::ds::SizeString max_size = {"200MB"};
+
+        bool operator==(const BackupFetch&) const = default;
+      };
+      BackupFetch backup_fetch = {};
+
       bool operator==(const Snapshots&) const = default;
     };
     Snapshots snapshots = {};

python/src/ccf/ledger.py

@@ -14,6 +14,7 @@
 
 from cryptography.x509 import load_pem_x509_certificate
 from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.backends import default_backend
 from cryptography.exceptions import InvalidSignature
 from cryptography.hazmat.primitives.asymmetric import utils, ec
 
@@ -44,6 +45,7 @@
 WELL_KNOWN_SINGLETON_TABLE_KEY = bytes(bytearray(8))
 
 SHA256_DIGEST_SIZE = sha256().digest_size
+ENCODED_COSE_SIGN1_TAG = 0xD2
 
 
 class NodeStatus(Enum):
@@ -1020,34 +1022,8 @@ def __init__(self, filename: str):
         if self.is_committed() and not self.is_snapshot_file_1_x():
             receipt_pos = entry_start_pos + self._header.size
             receipt_bytes = _peek_all(self._file, pos=receipt_pos)
-
-            try:
-                receipt = json.loads(receipt_bytes.decode("utf-8"))
-            except json.decoder.JSONDecodeError as e:
-                raise InvalidSnapshotException(
-                    f"Cannot read receipt from snapshot {os.path.basename(self._filename)}: Receipt starts at {receipt_pos} (file is {self._file_size} bytes), and contains {receipt_bytes}"
-                ) from e
-
-            # Receipts included in snapshots always contain leaf components,
-            # including a claims digest and commit evidence, from 2.0.0-rc0 onwards.
-            # This verification code deliberately does not support snapshots
-            # produced by 2.0.0-dev* releases.
-            assert "leaf_components" in receipt
-            write_set_digest = bytes.fromhex(
-                receipt["leaf_components"]["write_set_digest"]
-            )
-            claims_digest = bytes.fromhex(receipt["leaf_components"]["claims_digest"])
-            commit_evidence_digest = sha256(
-                receipt["leaf_components"]["commit_evidence"].encode()
-            ).digest()
-            leaf = (
-                sha256(write_set_digest + commit_evidence_digest + claims_digest)
-                .digest()
-                .hex()
-            )
-            root = ccf.receipt.root(leaf, receipt["proof"])
-            node_cert = load_pem_x509_certificate(receipt["cert"].encode())
-            ccf.receipt.verify(root, receipt["signature"], node_cert)
+            snapshot_digest = sha256(_peek(self._file, receipt_pos, pos=0)).digest()
+            self._verify_snapshot_receipt(receipt_bytes, receipt_pos, snapshot_digest)
 
     def is_committed(self):
         return COMMITTED_FILE_SUFFIX in self._filename
@@ -1061,6 +1037,88 @@ def is_snapshot_file_1_x(self):
     def get_len(self) -> int:
         return self._file_size
 
+    def _verify_snapshot_receipt(
+        self, receipt_bytes: bytes, receipt_pos: int, snapshot_digest: bytes
+    ):
+        if not receipt_bytes:
+            raise InvalidSnapshotException("Empty snapshot receipt")
+
+        first_byte = receipt_bytes[0]
+        if first_byte == ENCODED_COSE_SIGN1_TAG:
+            self._verify_cose_snapshot_receipt(receipt_bytes, snapshot_digest)
+        elif first_byte == ord("{"):
+            self._verify_json_snapshot_receipt(
+                receipt_bytes, receipt_pos, snapshot_digest
+            )
+        else:
+            raise InvalidSnapshotException(
+                f"Invalid snapshot receipt: unrecognised format (first byte: 0x{first_byte:02X})"
+            )
+
+    def _service_public_key(self):
+        service_info_table = (
+            self.get_public_domain().get_tables().get(SERVICE_INFO_TABLE_NAME)
+        )
+        if service_info_table is None:
+            raise InvalidSnapshotException(
+                "Snapshot is missing service info table for COSE receipt verification"
+            )
+
+        service_info = service_info_table.get(WELL_KNOWN_SINGLETON_TABLE_KEY)
+        if service_info is None:
+            raise InvalidSnapshotException(
+                "Snapshot is missing service info for COSE receipt verification"
+            )
+
+        service_info_json = json.loads(service_info)
+        cert = load_pem_x509_certificate(
+            service_info_json["cert"].encode("ascii"), default_backend()
+        )
+        return cert.public_key()
+
+    def _verify_cose_snapshot_receipt(
+        self, receipt_bytes: bytes, snapshot_digest: bytes
+    ):
+        ccf.cose.verify_receipt(
+            receipt_bytes, self._service_public_key(), snapshot_digest
+        )
+
+    def _verify_json_snapshot_receipt(
+        self, receipt_bytes: bytes, receipt_pos: int, snapshot_digest: bytes
+    ):
+        try:
+            receipt = json.loads(receipt_bytes.decode("utf-8"))
+        except json.decoder.JSONDecodeError as e:
+            raise InvalidSnapshotException(
+                f"Cannot read receipt from snapshot {os.path.basename(self._filename)}: Receipt starts at {receipt_pos} (file is {self._file_size} bytes), and contains {receipt_bytes!r}"
+            ) from e
+
+        # Receipts included in snapshots always contain leaf components,
+        # including a claims digest and commit evidence, from 2.0.0-rc0 onwards.
+        # This verification code deliberately does not support snapshots
+        # produced by 2.0.0-dev* releases.
+        assert "leaf_components" in receipt
+        write_set_digest = bytes.fromhex(receipt["leaf_components"]["write_set_digest"])
+        claims_digest = bytes.fromhex(receipt["leaf_components"]["claims_digest"])
+        if snapshot_digest != claims_digest:
+            raise InvalidSnapshotException(
+                f"Snapshot digest ({snapshot_digest.hex()}) does not match receipt claim ({claims_digest.hex()})"
+            )
+
+        commit_evidence_digest = sha256(
+            receipt["leaf_components"]["commit_evidence"].encode()
+        ).digest()
+        leaf = (
+            sha256(write_set_digest + commit_evidence_digest + claims_digest)
+            .digest()
+            .hex()
+        )
+        root = ccf.receipt.root(leaf, receipt["proof"])
+        node_cert = load_pem_x509_certificate(
+            receipt["cert"].encode(), default_backend()
+        )
+        ccf.receipt.verify(root, receipt["signature"], node_cert)
+
 
 class TransactionIterator:
     _positions: list[int]