structured-cades 0.21.3

Source-bound CAdES baseline composition over CMS and long-term validation facts
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! One whole earlier-actor census for modern and historical archive coverage.

use super::{ArchiveScopeError as Failure, Checked};
use crate::{
    Cades, Error, ISSUER,
    prepare::Preparation,
    source::{DocumentId, Node},
};
use structured_asn1::{
    Reader,
    memory::{Memory, Work},
};
use structured_ltv::{
    material::Coverage,
    source::{Scope, Source as _},
    timestamp::{RequiredToken, TimestampRequirements, TimestampScope},
};

pub(crate) fn derive<'m, 'd>(
    timestamp: &Checked<'m, 'd, '_>,
    coverage: &Coverage<Node, DocumentId<'m, 'd>, (), Memory, Cades>,
    prepared: &Preparation<'m, 'd>,
    operation: &Reader<'d>,
) -> Result<TimestampRequirements<Node, DocumentId<'m, 'd>, (), Cades>, Failure> {
    const FIELD: &str = "cades.archive.scope";
    prepared
        .document()
        .message()
        .require_session(operation, FIELD)
        .map_err(|cause| Failure::Processing(Error::Cms(cause)))?;
    let actor = timestamp.actor().ok_or(Failure::Unproven)?;
    let verified = actor.verified();
    operation
        .charge(1)
        .map_err(|cause| Failure::Processing(Error::encoding(cause, FIELD)))?;
    // Historical recipes also bind parallel roots and counters. Resolve the
    // actual retained owner in this preparation; a selected-root comparison
    // would discard an otherwise verified receipt for those owners.
    if verified.signature() != Node::of(prepared.signer().span()) {
        prepared
            .signer_encoding(verified.signature(), operation)
            .map_err(Failure::Processing)?;
    }
    let source = prepared.document();
    let work = operation.execution();
    let query = Scope::new(source, source.snapshot(), &work);
    coverage
        .require_evidence(verified, verified.property(), &query)
        .map_err(Failure::Coverage)?;
    let resource = |cause| {
        Failure::Processing(Error::resource(
            cause,
            FIELD,
            verified.property().span().start,
        ))
    };
    let mut tokens = work.vector();
    for entry in prepared.timestamps() {
        work.charge_work(1).map_err(resource)?;
        let token = entry
            .value()
            .map_or(entry.property(), |value| Node::of(value.span()));
        if token == verified.token().node && entry.owner() == verified.signature() {
            continue;
        }
        let selected = coverage
            .covers(verified, token, &query)
            .map_err(Failure::Coverage)?
            || coverage
                .covers(verified, entry.property(), &query)
                .map_err(Failure::Coverage)?;
        if selected {
            tokens
                .try_push(RequiredToken {
                    signature: entry.owner(),
                    property: entry.property(),
                    token,
                    purpose: entry.purpose(),
                })
                .map_err(resource)?;
        }
    }
    let owner = verified.signature().span();
    let catalogue = if owner.start >= prepared.signer().span().start
        && owner.end() <= prepared.signer().span().end()
    {
        prepared.counters()
    } else {
        prepared.parallel_counters()
    };
    let count = if verified.signature() == Node::of(prepared.signer().span()) {
        catalogue.len()
    } else {
        // A parallel-root catalogue can hold unrelated siblings. Reserve only
        // this owner's descendants, without copying or allocating a filter.
        counter_capacity(catalogue, verified.signature(), &work).map_err(resource)?
    };
    let mut counters = work.vector();
    let mut included = work.vector();
    counters.try_reserve_exact(count).map_err(resource)?;
    included.try_reserve_exact(count).map_err(resource)?;
    for counter in catalogue {
        work.charge_work(1).map_err(resource)?;
        if !descendant(verified.signature(), counter.node()) {
            continue;
        }
        let selected = coverage
            .covers(verified, counter.node(), &query)
            .map_err(Failure::Coverage)?;
        counters.try_push(counter.node()).map_err(resource)?;
        included.try_push(selected).map_err(resource)?;
    }
    Ok(TimestampRequirements::with_counters(
        ISSUER,
        verified.signature(),
        TimestampScope::BeforeArchive(source.locate(coverage.subject().span())),
        tokens.into_owned(),
        counters.into_owned(),
        Some(included.into_owned()),
    ))
}

fn descendant(owner: Node, child: Node) -> bool {
    let owner = owner.span();
    let child = child.span();
    child != owner && child.start >= owner.start && child.end() <= owner.end()
}

fn counter_capacity(
    catalogue: &[crate::prepare::Counter<'_>],
    owner: Node,
    work: &impl Work,
) -> Result<usize, structured_asn1::memory::MemoryError> {
    let mut count = 0;
    for counter in catalogue {
        work.charge_work(1)?;
        if descendant(owner, counter.node()) {
            count += 1;
        }
    }
    Ok(count)
}