evidence.rs (14606B)
1 //! Append-only protected obtained bytes and exact original observation data. 2 use super::{ 3 attempt, 4 crypto::{IssuancePayload, IssuanceScope, PRIVATE_PAYLOAD_MAX_BYTES, WorkspaceCrypto}, 5 }; 6 use radroots_domain::TransactionId; 7 use radroots_storage::command::protected::issuance::EvidenceManifest; 8 use radroots_storage::command::{ 9 ArtifactEvidence, EvidenceReceipt, OperationError, SigningAttempt, 10 }; 11 use sqlx::{Row, SqliteConnection}; 12 use zeroize::Zeroizing; 13 14 pub(super) const TABLE: &str = "CREATE TABLE artifact_evidence (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, artifact_key BLOB NOT NULL, attempt_id BLOB NOT NULL CHECK(length(attempt_id)=32), event_id BLOB NOT NULL CHECK(length(event_id)=32), evidence_digest BLOB NOT NULL CHECK(length(evidence_digest)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), part_count INTEGER NOT NULL CHECK(part_count BETWEEN 1 AND 4), byte_count INTEGER NOT NULL CHECK(byte_count BETWEEN 1 AND 65536), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,artifact_key), FOREIGN KEY(workspace,operation_id,artifact_key) REFERENCES signing_attempts(workspace,operation_id,artifact_key)) STRICT, WITHOUT ROWID"; 15 pub(super) const TABLE_V8: &str = "CREATE TABLE seal_evidence (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL, attempt_id BLOB NOT NULL CHECK(length(attempt_id)=32), event_id BLOB NOT NULL CHECK(length(event_id)=32), evidence_digest BLOB NOT NULL CHECK(length(evidence_digest)=32), transaction_id BLOB NOT NULL CHECK(length(transaction_id)=32), part_count INTEGER NOT NULL CHECK(part_count BETWEEN 1 AND 4), byte_count INTEGER NOT NULL CHECK(byte_count BETWEEN 1 AND 65536), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient), FOREIGN KEY(workspace,operation_id,recipient) REFERENCES signing_attempts(workspace,operation_id,recipient)) STRICT, WITHOUT ROWID"; 16 pub(super) const PARTS: &str = "CREATE TABLE artifact_evidence_parts (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, artifact_key BLOB NOT NULL, part INTEGER NOT NULL CHECK(part BETWEEN 1 AND 4), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,artifact_key,part), FOREIGN KEY(workspace,operation_id,artifact_key) REFERENCES artifact_evidence(workspace,operation_id,artifact_key)) STRICT, WITHOUT ROWID"; 17 pub(super) const PARTS_V8: &str = "CREATE TABLE seal_evidence_parts (workspace BLOB NOT NULL, operation_id BLOB NOT NULL, recipient BLOB NOT NULL, part INTEGER NOT NULL CHECK(part BETWEEN 1 AND 4), protected BLOB NOT NULL CHECK(length(protected)>0 AND length(protected)<=262144), PRIMARY KEY(workspace,operation_id,recipient,part), FOREIGN KEY(workspace,operation_id,recipient) REFERENCES seal_evidence(workspace,operation_id,recipient)) STRICT, WITHOUT ROWID"; 18 pub(super) const TX_INDEX: &str = "CREATE UNIQUE INDEX artifact_evidence_transaction_identity ON artifact_evidence(workspace,transaction_id)"; 19 pub(super) const TX_INDEX_V8: &str = "CREATE UNIQUE INDEX seal_evidence_transaction_identity ON seal_evidence(workspace,transaction_id)"; 20 const MAX_PROTECTED_TOTAL: usize = 1024 * 1024; 21 pub(super) struct ProtectedEvidence { 22 pub manifest: Vec<u8>, 23 pub parts: Vec<Vec<u8>>, 24 pub receipt: EvidenceReceipt, 25 pub bytes: usize, 26 } 27 pub(super) async fn protect( 28 attempt: &SigningAttempt, 29 evidence: &ArtifactEvidence, 30 transaction: TransactionId, 31 crypto: &WorkspaceCrypto, 32 ) -> Result<ProtectedEvidence, OperationError> { 33 if !evidence.matches_attempt(attempt) { 34 return Err(OperationError::InvalidEvidence); 35 } 36 let bytes = evidence.raw_json().as_bytes(); 37 let chunks = bytes.chunks(PRIVATE_PAYLOAD_MAX_BYTES); 38 let receipt = EvidenceReceipt::from_committed_store(evidence, transaction); 39 let manifest = EvidenceManifest::capture(attempt, evidence, transaction)?; 40 let plaintext = manifest.encode()?; 41 let scope = attempt::scope(attempt)?; 42 let manifest = crypto 43 .seal_issuance(scope, IssuancePayload::Evidence, 0, &plaintext) 44 .await?; 45 let mut total = manifest.len(); 46 let mut parts = Vec::new(); 47 for (index, chunk) in chunks.enumerate() { 48 let part = crypto 49 .seal_issuance(scope, IssuancePayload::Evidence, (index + 1) as u8, chunk) 50 .await?; 51 total = total 52 .checked_add(part.len()) 53 .filter(|size| *size <= MAX_PROTECTED_TOTAL) 54 .ok_or(OperationError::InvalidEvidence)?; 55 parts.push(part); 56 } 57 Ok(ProtectedEvidence { 58 manifest, 59 parts, 60 receipt, 61 bytes: bytes.len(), 62 }) 63 } 64 pub(super) async fn read( 65 connection: &mut SqliteConnection, 66 attempt: &SigningAttempt, 67 crypto: &WorkspaceCrypto, 68 ) -> Result<Option<(ArtifactEvidence, ProtectedEvidence)>, OperationError> { 69 let scope = attempt::scope(attempt)?; 70 let row=sqlx::query(attempt::sql(connection, "SELECT CASE WHEN length(attempt_id)=32 THEN attempt_id END,CASE WHEN length(event_id)=32 THEN event_id END,CASE WHEN length(evidence_digest)=32 THEN evidence_digest END,CASE WHEN length(transaction_id)=32 THEN transaction_id END,part_count,byte_count,CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM seal_evidence WHERE workspace=? AND operation_id=? AND recipient=?").await?) 71 .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).fetch_optional(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; 72 let Some(row) = row else { 73 return Ok(None); 74 }; 75 let value = |index| { 76 row.try_get::<Option<Vec<u8>>, _>(index) 77 .map_err(|_| OperationError::RecoveryRequired)? 78 .ok_or(OperationError::RecoveryRequired) 79 }; 80 let attempt_id = value(0)?; 81 let event_id = value(1)?; 82 let digest = value(2)?; 83 let transaction = value(3)?; 84 let manifest = value(6)?; 85 let count: i64 = row 86 .try_get(4) 87 .map_err(|_| OperationError::RecoveryRequired)?; 88 let bytes: i64 = row 89 .try_get(5) 90 .map_err(|_| OperationError::RecoveryRequired)?; 91 if !(1..=4).contains(&count) 92 || !(1..=65536).contains(&bytes) 93 || (bytes as usize).div_ceil(PRIVATE_PAYLOAD_MAX_BYTES) != count as usize 94 { 95 return Err(OperationError::RecoveryRequired); 96 } 97 let transaction = TransactionId::from_bytes( 98 transaction 99 .try_into() 100 .map_err(|_| OperationError::RecoveryRequired)?, 101 ); 102 let plaintext = crypto 103 .open_issuance(scope, IssuancePayload::Evidence, 0, &manifest) 104 .await?; 105 let decoded = plaintext.expose_secret(|raw| EvidenceManifest::decode(raw, attempt))?; 106 if decoded.event_id().as_bytes().as_slice() != event_id.as_slice() 107 || decoded.attempt_id().as_bytes().as_slice() != attempt_id.as_slice() 108 || decoded.evidence_digest().as_slice() != digest.as_slice() 109 || decoded.transaction_id() != transaction 110 || decoded.part_count() != count as usize 111 || decoded.byte_count() != bytes as usize 112 { 113 return Err(OperationError::RecoveryRequired); 114 } 115 let (parts,total):(i64,i64)=sqlx::query_as(attempt::sql(connection, "SELECT count(*),coalesce(sum(length(protected)),0) FROM seal_evidence_parts WHERE workspace=? AND operation_id=? AND recipient=?").await?) 116 .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; 117 if parts != count || total <= 0 || total > (MAX_PROTECTED_TOTAL - manifest.len()) as i64 { 118 return Err(OperationError::RecoveryRequired); 119 } 120 let rows=sqlx::query(attempt::sql(connection, "SELECT part,CASE WHEN length(protected)>0 AND length(protected)<=262144 AND (SELECT coalesce(sum(length(p.protected)),0) FROM seal_evidence_parts p WHERE p.workspace=seal_evidence_parts.workspace AND p.operation_id=seal_evidence_parts.operation_id AND p.recipient=seal_evidence_parts.recipient)<=1048576 THEN protected END FROM seal_evidence_parts WHERE workspace=? AND operation_id=? AND recipient=? ORDER BY part LIMIT 5").await?) 121 .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).fetch_all(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; 122 if rows.len() != count as usize { 123 return Err(OperationError::RecoveryRequired); 124 } 125 let mut raw = Zeroizing::new(Vec::with_capacity(bytes as usize)); 126 let mut protected_parts = Vec::new(); 127 for (index, row) in rows.iter().enumerate() { 128 let number: i64 = row 129 .try_get(0) 130 .map_err(|_| OperationError::RecoveryRequired)?; 131 if number != (index + 1) as i64 { 132 return Err(OperationError::RecoveryRequired); 133 } 134 let protected: Vec<u8> = row 135 .try_get::<Option<Vec<u8>>, _>(1) 136 .map_err(|_| OperationError::RecoveryRequired)? 137 .ok_or(OperationError::RecoveryRequired)?; 138 let part = crypto 139 .open_issuance(scope, IssuancePayload::Evidence, number as u8, &protected) 140 .await?; 141 let length = if index + 1 == rows.len() { 142 bytes as usize - index * PRIVATE_PAYLOAD_MAX_BYTES 143 } else { 144 PRIVATE_PAYLOAD_MAX_BYTES 145 }; 146 part.expose_secret(|value| { 147 if value.len() != length { 148 return Err(OperationError::RecoveryRequired); 149 } 150 raw.extend_from_slice(value); 151 Ok(()) 152 })?; 153 protected_parts.push(protected); 154 } 155 let text = core::str::from_utf8(&raw).map_err(|_| OperationError::RecoveryRequired)?; 156 let evidence = decoded.verify(attempt, text)?; 157 let receipt = EvidenceReceipt::from_committed_store(&evidence, transaction); 158 Ok(Some(( 159 evidence, 160 ProtectedEvidence { 161 manifest, 162 parts: protected_parts, 163 receipt, 164 bytes: bytes as usize, 165 }, 166 ))) 167 } 168 pub(super) async fn insert( 169 connection: &mut SqliteConnection, 170 value: &ProtectedEvidence, 171 ) -> Result<(), OperationError> { 172 let receipt = value.receipt; 173 sqlx::query(attempt::sql(connection, "INSERT INTO seal_evidence(workspace,operation_id,recipient,attempt_id,event_id,evidence_digest,transaction_id,part_count,byte_count,protected) VALUES(?,?,?,?,?,?,?,?,?,?)").await?) 174 .bind(receipt.workspace_id().as_bytes().as_slice()).bind(receipt.operation_id().as_bytes().as_slice()).bind(receipt.target().key().as_slice()).bind(receipt.attempt_id().as_bytes().as_slice()).bind(receipt.event_id().as_bytes().as_slice()).bind(receipt.digest().as_slice()).bind(receipt.transaction_id().as_bytes().as_slice()).bind(value.parts.len() as i64).bind(value.bytes as i64).bind(&value.manifest).execute(&mut *connection).await.map_err(|_|OperationError::StorageFailure)?; 175 for (index, part) in value.parts.iter().enumerate() { 176 sqlx::query(attempt::sql(connection, "INSERT INTO seal_evidence_parts(workspace,operation_id,recipient,part,protected) VALUES(?,?,?,?,?)").await?) 177 .bind(receipt.workspace_id().as_bytes().as_slice()).bind(receipt.operation_id().as_bytes().as_slice()).bind(receipt.target().key().as_slice()).bind((index+1) as i64).bind(part).execute(&mut *connection).await.map_err(|_|OperationError::StorageFailure)?; 178 } 179 Ok(()) 180 } 181 pub(super) async fn unchanged( 182 connection: &mut SqliteConnection, 183 attempt: &SigningAttempt, 184 value: Option<&ProtectedEvidence>, 185 ) -> Result<(), OperationError> { 186 unchanged_scope(connection, attempt::scope(attempt)?, value).await 187 } 188 pub(super) async fn unchanged_scope( 189 connection: &mut SqliteConnection, 190 scope: IssuanceScope, 191 value: Option<&ProtectedEvidence>, 192 ) -> Result<(), OperationError> { 193 let count: i64 = sqlx::query_scalar(attempt::sql(connection, "SELECT count(*) FROM seal_evidence WHERE workspace=? AND operation_id=? AND recipient=?").await?) 194 .bind(scope.workspace.as_bytes().as_slice()) 195 .bind(scope.operation.as_bytes().as_slice()) 196 .bind(scope.target.key().as_slice()) 197 .fetch_one(&mut *connection) 198 .await 199 .map_err(|_| OperationError::RecoveryRequired)?; 200 let parts:i64=sqlx::query_scalar(attempt::sql(connection, "SELECT count(*) FROM seal_evidence_parts WHERE workspace=? AND operation_id=? AND recipient=?").await?) 201 .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; 202 let Some(value) = value else { 203 return if count == 0 && parts == 0 { 204 Ok(()) 205 } else { 206 Err(OperationError::RecoveryRequired) 207 }; 208 }; 209 let receipt = value.receipt; 210 let matched:i64=sqlx::query_scalar(attempt::sql(connection, "SELECT count(*) FROM seal_evidence WHERE workspace=? AND operation_id=? AND recipient=? AND attempt_id=? AND event_id=? AND evidence_digest=? AND transaction_id=? AND part_count=? AND byte_count=? AND protected=?").await?) 211 .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).bind(receipt.attempt_id().as_bytes().as_slice()).bind(receipt.event_id().as_bytes().as_slice()).bind(receipt.digest().as_slice()).bind(receipt.transaction_id().as_bytes().as_slice()).bind(value.parts.len() as i64).bind(value.bytes as i64).bind(&value.manifest).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; 212 if count != 1 || matched != 1 || parts != value.parts.len() as i64 { 213 return Err(OperationError::RecoveryRequired); 214 } 215 for (index, part) in value.parts.iter().enumerate() { 216 let matched:i64=sqlx::query_scalar(attempt::sql(connection, "SELECT count(*) FROM seal_evidence_parts WHERE workspace=? AND operation_id=? AND recipient=? AND part=? AND protected=?").await?) 217 .bind(scope.workspace.as_bytes().as_slice()).bind(scope.operation.as_bytes().as_slice()).bind(scope.target.key().as_slice()).bind((index+1) as i64).bind(part).fetch_one(&mut *connection).await.map_err(|_|OperationError::RecoveryRequired)?; 218 if matched != 1 { 219 return Err(OperationError::RecoveryRequired); 220 } 221 } 222 Ok(()) 223 }