lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }