checkpoint.rs (6321B)
1 use super::*; 2 use sqlx::Row; 3 pub(in crate::workspace::stock) enum Target { 4 Minimum(StockSourceCheckpointRef), 5 Envelope( 6 EnvelopeEventId, 7 Option<(Sequence, CheckpointDigest, [u8; 32])>, 8 ), 9 Record(RecordId, Option<[u8; 32]>), 10 } 11 pub(in crate::workspace::stock) struct Proof { 12 lower: u64, 13 upper: u64, 14 digest: [u8; 32], 15 } 16 fn hash() -> Sha256 { 17 let mut value = Sha256::new(); 18 value.update(b"radroots.seller_stock.source_ancestry_snapshot.v1\0"); 19 value 20 } 21 fn hash_row( 22 hash: &mut Sha256, 23 revision: u64, 24 envelope: &[u8], 25 record: Option<&[u8]>, 26 transaction: &[u8], 27 head: &[u8], 28 protected: &[u8], 29 ) { 30 hash.update(revision.to_be_bytes()); 31 hash.update(envelope); 32 hash.update([u8::from(record.is_some())]); 33 if let Some(record) = record { 34 hash.update(record); 35 } 36 hash.update(transaction); 37 hash.update(head); 38 hash.update((protected.len() as u64).to_be_bytes()); 39 hash.update(protected); 40 } 41 impl Proof { 42 pub async fn confirm(&self, connection: &mut SqliteConnection) -> Result<(), OperationError> { 43 let mut hash = hash(); 44 for revision in (self.lower..=self.upper).rev() { 45 let row=sqlx::query("SELECT envelope_id,record_id,transaction_id,chain_head,CASE WHEN length(protected) BETWEEN 1 AND 262144 THEN protected END FROM stock_source_evidence WHERE revision=?").bind(revision as i64).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; 46 let envelope: Vec<u8> = row 47 .try_get(0) 48 .map_err(|_| OperationError::RecoveryRequired)?; 49 let record: Option<Vec<u8>> = row 50 .try_get(1) 51 .map_err(|_| OperationError::RecoveryRequired)?; 52 let tx: Vec<u8> = row 53 .try_get(2) 54 .map_err(|_| OperationError::RecoveryRequired)?; 55 let head: Vec<u8> = row 56 .try_get(3) 57 .map_err(|_| OperationError::RecoveryRequired)?; 58 let protected: Vec<u8> = row 59 .try_get::<Option<Vec<u8>>, _>(4) 60 .map_err(|_| OperationError::RecoveryRequired)? 61 .ok_or(OperationError::RecoveryRequired)?; 62 if envelope.len() != 32 63 || tx.len() != 32 64 || head.len() != 32 65 || record.as_ref().is_some_and(|value| value.len() != 32) 66 { 67 return Err(OperationError::RecoveryRequired); 68 } 69 hash_row( 70 &mut hash, 71 revision, 72 &envelope, 73 record.as_deref(), 74 &tx, 75 &head, 76 &protected, 77 ); 78 } 79 let actual: [u8; 32] = hash.finalize().into(); 80 if actual != self.digest { 81 return Err(OperationError::RecoveryRequired); 82 } 83 Ok(()) 84 } 85 } 86 pub(in crate::workspace::stock) async fn authenticate( 87 connection: &mut SqliteConnection, 88 input: &AttachmentInput, 89 crypto: &WorkspaceCrypto, 90 current: SourceCheckpoint, 91 target: Target, 92 ) -> Result<Proof, OperationError> { 93 let upper = current.revision.get(); 94 if let Target::Minimum(minimum) = target 95 && (minimum.authority() != input.authority() || minimum.revision().get() > upper) 96 { 97 return Err(WorkspaceError::StaleCheckpoint.into()); 98 } 99 let mut expected = current.head; 100 let mut hash = hash(); 101 for revision in (1..=upper).rev() { 102 let id:Vec<u8>=sqlx::query_scalar("SELECT envelope_id FROM stock_source_evidence WHERE revision=? AND length(envelope_id)=32").bind(revision as i64).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?.ok_or(OperationError::RecoveryRequired)?; 103 let envelope = EnvelopeEventId::from_bytes( 104 id.try_into() 105 .map_err(|_| OperationError::RecoveryRequired)?, 106 ); 107 let retained = record::read(connection, input, crypto, envelope) 108 .await? 109 .ok_or(OperationError::RecoveryRequired)?; 110 let header = &retained.header; 111 if header.revision.get() != revision || Some(header.head) != expected { 112 return Err(OperationError::RecoveryRequired); 113 } 114 hash_row( 115 &mut hash, 116 revision, 117 envelope.as_bytes(), 118 header 119 .manifest 120 .record 121 .as_ref() 122 .map(|id| id.as_bytes().as_slice()), 123 header.transaction.as_bytes(), 124 header.head.as_bytes(), 125 &retained.protected, 126 ); 127 let matched = match &target { 128 Target::Minimum(minimum) if minimum.revision().get() == revision => { 129 if minimum.head() != Some(header.head) { 130 return Err(WorkspaceError::StaleCheckpoint.into()); 131 } 132 true 133 } 134 Target::Envelope(id, observed) if *id == envelope => { 135 let digest: [u8; 32] = Sha256::digest(&retained.protected).into(); 136 if *observed != Some((header.revision, header.head, digest)) { 137 return Err(OperationError::RecoveryRequired); 138 } 139 true 140 } 141 Target::Record(id, observed) if header.manifest.record == Some(*id) => { 142 if *observed != header.manifest.canonical_digest { 143 return Err(OperationError::RecoveryRequired); 144 } 145 true 146 } 147 _ => false, 148 }; 149 if matched { 150 return Ok(Proof { 151 lower: revision, 152 upper, 153 digest: hash.finalize().into(), 154 }); 155 } 156 expected = header.previous; 157 } 158 let absent = match target { 159 Target::Minimum(value) => value.revision().get() == 0 && value.head().is_none(), 160 Target::Envelope(_, value) => value.is_none(), 161 Target::Record(_, value) => value.is_none(), 162 }; 163 if expected.is_some() || !absent { 164 return Err(OperationError::RecoveryRequired); 165 } 166 Ok(Proof { 167 lower: 1, 168 upper, 169 digest: hash.finalize().into(), 170 }) 171 }