removes get_signed_data_offsets

ledger/src/shred.rs

@@ -656,16 +656,18 @@ pub mod layout {
 
     // Returns offsets within the shred payload which is signed.
     pub(crate) fn get_signed_data_offsets(shred: &[u8]) -> Option<Range<usize>> {
-        let offsets = match get_shred_variant(shred).ok()? {
-            ShredVariant::LegacyCode | ShredVariant::LegacyData => legacy::SIGNED_MESSAGE_OFFSETS,
-            ShredVariant::MerkleCode(proof_size) => {
-                merkle::ShredCode::get_signed_data_offsets(proof_size)?
-            }
-            ShredVariant::MerkleData(proof_size) => {
-                merkle::ShredData::get_signed_data_offsets(proof_size)?
-            }
-        };
-        (offsets.end <= shred.len()).then_some(offsets)
+        match get_shred_variant(shred).ok()? {
+            ShredVariant::LegacyCode | ShredVariant::LegacyData => {
+                let offsets = self::legacy::SIGNED_MESSAGE_OFFSETS;
+                (offsets.end <= shred.len()).then_some(offsets)
+            },
+            // Merkle shreds sign merkle tree root which can be recovered from
+            // the merkle proof embedded in the payload but itself is not
+            // stored the payload.
+            // XXX anyway to make this more foolproof?
+            ShredVariant::MerkleCode(_) => None,
+            ShredVariant::MerkleData(_) => None,
+        }
     }
 
     pub(crate) fn get_reference_tick(shred: &[u8]) -> Result<u8, Error> {
@@ -716,15 +718,15 @@ pub mod layout {
             modify_packet(rng, packet, 0..SIGNATURE_BYTES);
         } else {
             // Corrupt one byte within the signed data offsets.
-            let size = shred.len();
-            let offsets = get_signed_data_offsets(shred).unwrap();
-            modify_packet(rng, packet, offsets);
-            if let Some(proof_size) = merkle_proof_size {
-                // Also need to corrupt the merkle proof.
-                // Proof entries are each 20 bytes at the end of shreds.
-                let offset = usize::from(proof_size) * 20;
-                modify_packet(rng, packet, size - offset..size);
-            }
+            let offsets = merkle_proof_size
+                .map(|merkle_proof_size| {
+                    // Need to corrupt the merkle proof.
+                    // Proof entries are each 20 bytes at the end of shreds.
+                    let offset = usize::from(merkle_proof_size) * 20;
+                    shred.len() - offset..shred.len()
+                })
+                .or_else(|| get_signed_data_offsets(shred));
+            modify_packet(rng, packet, offsets.unwrap());
         }
         // Assert that the signature no longer verifies.
         let shred = get_shred(packet).unwrap();
@@ -734,8 +736,9 @@ pub mod layout {
             let pubkey = keypairs[&slot].pubkey();
             let data = get_signed_data(shred).unwrap();
             assert!(!signature.verify(pubkey.as_ref(), data.as_ref()));
-            let offsets = get_signed_data_offsets(shred).unwrap();
-            assert!(!signature.verify(pubkey.as_ref(), &shred[offsets]));
+            if let Some(offsets) = get_signed_data_offsets(shred) {
+                assert!(!signature.verify(pubkey.as_ref(), &shred[offsets]));
+            }
         } else {
             // Slot may have been corrupted and no longer mapping to a keypair.
             let pubkey = keypairs.get(&slot).map(Keypair::pubkey).unwrap_or_default();

ledger/src/shred/merkle.rs

@@ -30,7 +30,6 @@ use {
     static_assertions::const_assert_eq,
     std::{
         io::{Cursor, Write},
-        ops::Range,
         time::Instant,
     },
 };
@@ -149,12 +148,6 @@ impl ShredData {
             .ok_or(Error::InvalidProofSize(proof_size))
     }
 
-    pub(super) fn get_signed_data_offsets(proof_size: u8) -> Option<Range<usize>> {
-        let data_buffer_size = Self::capacity(proof_size).ok()?;
-        let offset = Self::SIZE_OF_HEADERS + data_buffer_size;
-        Some(offset..offset + SIZE_OF_MERKLE_ROOT)
-    }
-
     fn merkle_root(&self) -> Result<&MerkleRoot, Error> {
         let proof_size = self.proof_size()?;
         let offset = Self::SIZE_OF_HEADERS + Self::capacity(proof_size)?;
@@ -333,11 +326,6 @@ impl ShredCode {
         Ok(verify_merkle_proof(index, node, &self.merkle_branch()?))
     }
 
-    pub(super) fn get_signed_data_offsets(proof_size: u8) -> Option<Range<usize>> {
-        let offset = Self::SIZE_OF_HEADERS + Self::capacity(proof_size).ok()?;
-        Some(offset..offset + SIZE_OF_MERKLE_ROOT)
-    }
-
     fn from_recovered_shard(
         common_header: ShredCommonHeader,
         coding_header: CodingShredHeader,
@@ -1510,9 +1498,6 @@ mod test {
             assert_eq!(shred::layout::get_version(shred), Some(version));
             assert_eq!(shred::layout::get_shred_id(shred), Some(key));
             assert_eq!(shred::layout::get_merkle_root(shred), merkle_root);
-            let offsets = shred::layout::get_signed_data_offsets(shred).unwrap();
-            let data = shred.get(offsets).unwrap();
-            assert!(signature.verify(pubkey.as_ref(), data));
             let data = shred::layout::get_signed_data(shred).unwrap();
             assert!(signature.verify(pubkey.as_ref(), data.as_ref()));
         }

ledger/src/sigverify_shreds.rs

@@ -807,9 +807,10 @@ mod tests {
             let shred = shred.payload();
             let slot = shred::layout::get_slot(shred).unwrap();
             let signature = shred::layout::get_signature(shred).unwrap();
-            let offsets = shred::layout::get_signed_data_offsets(shred).unwrap();
             let pubkey = keypairs[&slot].pubkey();
-            assert!(signature.verify(pubkey.as_ref(), &shred[offsets]));
+            if let Some(offsets) = shred::layout::get_signed_data_offsets(shred) {
+                assert!(signature.verify(pubkey.as_ref(), &shred[offsets]));
+            }
             let data = shred::layout::get_signed_data(shred).unwrap();
             assert!(signature.verify(pubkey.as_ref(), data.as_ref()));
         }