feat: add kes ocert validation

Author: golddydev

Cargo.lock

@@ -229,10 +229,12 @@ impl PartialEq for BadVrfProofError {
 /// https://github.com/IntersectMBO/ouroboros-consensus/blob/e3c52b7c583bdb6708fac4fdaa8bf0b9588f5a88/ouroboros-consensus-protocol/src/ouroboros-consensus-protocol/Ouroboros/Consensus/Protocol/Praos.hs#L342
 #[derive(Error, Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq)]
 pub enum KesValidationError {
-    #[error("{0}")]
+    #[error("KES Signature Error: {0}")]
     KesSignatureError(#[from] KesSignatureError),
-    #[error("{0}")]
+    #[error("Operational Certificate Error: {0}")]
     OperationalCertificateError(#[from] OperationalCertificateError),
+    #[error("Other Kes Validation Error: {0}")]
+    Other(String),
 }
 
 #[derive(Error, Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq)]
@@ -274,36 +276,35 @@ pub enum KesSignatureError {
 
 #[derive(Error, Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq)]
 pub enum OperationalCertificateError {
+    /// **Cause:** The operational certificate is malformed.
+    #[error("Malformed Signature OCert: Reason={}", reason)]
+    MalformedSignatureOcert { reason: String },
+    /// **Cause:** The cold key signature on the operational certificate is invalid.
+    /// The OCert was not properly signed by the pool's cold key.
+    #[error("Invalid Signature OCert: Issuer={}", hex::encode(issuer))]
+    InvalidSignatureOcert { issuer: Vec<u8> },
     /// **Cause:** The operational certificate counter in the header is not greater
     /// than the last counter used by this pool.
     #[error(
-        "Counter Too Small OCert: Last Counter={}, Current Counter={}",
-        last_counter,
-        current_counter
+        "Counter Too Small OCert: Latest Counter={}, Declared Counter={}",
+        latest_counter,
+        declared_counter
     )]
     CounterTooSmallOcert {
-        last_counter: u64,
-        current_counter: u64,
+        latest_counter: u64,
+        declared_counter: u64,
     },
     /// **Cause:** OCert counter jumped by more than 1. While not strictly invalid,
     /// this is suspicious and may indicate key compromise. (Praos Only)
     #[error(
-        "Counter Over Incremented OCert: Last Counter={}, Current Counter={}",
-        last_counter,
-        current_counter
+        "Counter Over Incremented OCert: Latest Counter={}, Declared Counter={}",
+        latest_counter,
+        declared_counter
     )]
     CounterOverIncrementedOcert {
-        last_counter: u64,
-        current_counter: u64,
+        latest_counter: u64,
+        declared_counter: u64,
     },
-    /// **Cause:** The cold key signature on the operational certificate is invalid.
-    /// The OCert was not properly signed by the pool's cold key.
-    #[error(
-        "Invalid Signature OCert: Counter={}, KES Period={}",
-        counter,
-        kes_period
-    )]
-    InvalidSignatureOcert { counter: u64, kes_period: u64 },
     /// **Cause:** No counter found for this key hash (not a stake pool or genesis delegate)
     #[error("No Counter For Key Hash OCert: Pool ID={}", hex::encode(pool_id))]
     NoCounterForKeyHashOcert { pool_id: PoolId },

common/src/validation.rs

@@ -21,9 +21,8 @@ tokio = { workspace = true }
 tracing = { workspace = true }
 serde_json = { workspace = true }
 serde = { workspace = true }
-blake2 = "0.10.6"
-num-traits = "0.2"
 thiserror = "2.0.17"
+pallas = { workspace = true }
 
 kes-summed-ed25519 = { git = "https://github.com/txpipe/kes", rev = "f69fb357d46f6a18925543d785850059569d7e78" }
 

modules/block_kes_validator/Cargo.toml

@@ -1 +1,2 @@
-mod kes;
+pub mod kes;
+pub mod praos;

modules/block_kes_validator/src/ouroboros/mod.rs

@@ -0,0 +1,56 @@
+use acropolis_common::validation::OperationalCertificateError;
+use pallas::crypto::key::ed25519;
+
+pub struct OperationalCertificate<'a> {
+    pub operational_cert_hot_vkey: &'a [u8],
+    pub operational_cert_sequence_number: u64,
+    pub operational_cert_kes_period: u64,
+    pub operational_cert_sigma: &'a [u8],
+}
+
+pub fn validate_operational_certificate<'a>(
+    certificate: OperationalCertificate<'a>,
+    issuer: &ed25519::PublicKey,
+    latest_sequence_number: u64,
+    is_praos: bool,
+) -> Result<(), OperationalCertificateError> {
+    // Verify the Operational Certificate signature
+    let signature =
+        ed25519::Signature::try_from(certificate.operational_cert_sigma).map_err(|error| {
+            OperationalCertificateError::MalformedSignatureOcert {
+                reason: error.to_string(),
+            }
+        })?;
+
+    let declared_sequence_number = certificate.operational_cert_sequence_number;
+
+    // Check the sequence number of the operational certificate. It should either be the same
+    // as the latest known sequence number for the issuer or one greater.
+    if declared_sequence_number < latest_sequence_number {
+        return Err(OperationalCertificateError::CounterTooSmallOcert {
+            latest_counter: latest_sequence_number,
+            declared_counter: declared_sequence_number,
+        });
+    }
+
+    // this is only for praos protocol
+    if is_praos && (declared_sequence_number - latest_sequence_number) > 1 {
+        return Err(OperationalCertificateError::CounterOverIncrementedOcert {
+            latest_counter: latest_sequence_number,
+            declared_counter: declared_sequence_number,
+        });
+    }
+
+    // The opcert message is a concatenation of the KES vkey, the sequence number, and the kes period
+    let mut message = Vec::new();
+    message.extend_from_slice(certificate.operational_cert_hot_vkey);
+    message.extend_from_slice(&certificate.operational_cert_sequence_number.to_be_bytes());
+    message.extend_from_slice(&certificate.operational_cert_kes_period.to_be_bytes());
+    if !issuer.verify(&message, &signature) {
+        return Err(OperationalCertificateError::InvalidSignatureOcert {
+            issuer: issuer.as_ref().to_vec(),
+        });
+    }
+
+    Ok(())
+}

modules/block_kes_validator/src/ouroboros/praos.rs

@@ -1,8 +1,11 @@
+use crate::ouroboros::praos::OperationalCertificate;
 use acropolis_common::{
     genesis_values::GenesisValues, messages::ProtocolParamsMessage, validation::KesValidationError,
     BlockInfo, PoolId,
 };
 use imbl::HashMap;
+use pallas::ledger::{primitives::babbage::OperationalCert, traverse::MultiEraHeader};
+use tracing::error;
 
 #[derive(Default, Debug, Clone)]
 pub struct State {
@@ -35,6 +38,61 @@ impl State {
         raw_header: &[u8],
         genesis: &GenesisValues,
     ) -> Result<(), Box<KesValidationError>> {
+        // Validation starts after Shelley Era
+        if block_info.epoch < genesis.shelley_epoch {
+            return Ok(());
+        }
+
+        let header = match MultiEraHeader::decode(block_info.era as u8, None, raw_header) {
+            Ok(header) => header,
+            Err(e) => {
+                error!("Can't decode header {}: {e}", block_info.slot);
+                return Err(Box::new(KesValidationError::Other(format!(
+                    "Can't decode header {}: {e}",
+                    block_info.slot
+                ))));
+            }
+        };
+
+        let Some(slots_per_kes_period) = self.slots_per_kes_period else {
+            return Err(Box::new(KesValidationError::Other(
+                "Slots per KES period is not set".to_string(),
+            )));
+        };
+        let Some(max_kes_evolutions) = self.max_kes_evolutions else {
+            return Err(Box::new(KesValidationError::Other(
+                "Max KES evolutions is not set".to_string(),
+            )));
+        };
+
+        let cert = operational_cert(&header).ok_or(Box::new(KesValidationError::Other(
+            "Can't get operational certificate".to_string(),
+        )))?;
+
         Ok(())
     }
 }
+
+fn operational_cert<'a>(header: &'a MultiEraHeader) -> Option<OperationalCertificate<'a>> {
+    match header {
+        MultiEraHeader::BabbageCompatible(x) => Some(OperationalCertificate {
+            operational_cert_hot_vkey: &x.header_body.operational_cert.operational_cert_hot_vkey,
+            operational_cert_sequence_number: x
+                .header_body
+                .operational_cert
+                .operational_cert_sequence_number,
+            operational_cert_kes_period: x.header_body.operational_cert.operational_cert_kes_period,
+            operational_cert_sigma: &x.header_body.operational_cert.operational_cert_sigma,
+        }),
+        MultiEraHeader::ShelleyCompatible(x) => {
+            let cert = OperationalCertificate {
+                operational_cert_hot_vkey: &x.header_body.operational_cert_hot_vkey,
+                operational_cert_sequence_number: x.header_body.operational_cert_sequence_number,
+                operational_cert_kes_period: x.header_body.operational_cert_kes_period,
+                operational_cert_sigma: &x.header_body.operational_cert_sigma,
+            };
+            Some(cert)
+        }
+        _ => None,
+    }
+}