structured-pades 0.21.3

Original-source PDF signatures and provider-neutral PAdES baseline validation
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

//! Sealed translation of actual CMS facts into their original PDF enclosure.

use crate::{
    error::{Error, ErrorKind},
    model::admit,
    source::Location,
    timestamp::{ISSUER, Node, Pades},
};
use structured_asn1::memory::Work;
use structured_cades::{
    Cades,
    source::{DocumentId, Node as CmsNode},
};
use structured_ltv::{
    source::{Location as Original, Snapshot},
    timestamp::{CheckedActor, Verified},
};

pub(crate) struct InnerQuery<'q, 'm, 'd, D, G, Q> {
    pub(crate) outer: &'q Q,
    pub(crate) mapping: Mapping<'m, 'd, D, G>,
}
impl<
    'm,
    'd,
    D: Copy + Eq,
    G: Copy + Eq,
    Q: structured_ltv::source::Query<Id = Node, Document = D, Generation = G>,
> structured_ltv::source::Query for InnerQuery<'_, 'm, 'd, D, G, Q>
{
    type Id = CmsNode;
    type Document = DocumentId<'m, 'd>;
    type Generation = ();
    type Work = Q::Work;
    fn snapshot(&self) -> Snapshot<Self::Document, ()> {
        self.mapping.cms
    }
    fn execution(&self) -> &Q::Work {
        self.outer.execution()
    }
    fn admit(
        &self,
        node: CmsNode,
        units: u64,
    ) -> Result<(), structured_ltv::source::ScopeError<CmsNode>> {
        self.outer
            .admit(self.mapping.node(node), units)
            .map_err(|cause| match cause {
                structured_ltv::source::ScopeError::Changed { .. } => {
                    structured_ltv::source::ScopeError::Changed { node }
                }
                structured_ltv::source::ScopeError::Resource { cause, .. } => {
                    structured_ltv::source::ScopeError::Resource { node, cause }
                }
            })
    }
}

#[derive(Clone, Copy)]
pub(crate) struct Mapping<'m, 'd, D, G> {
    pub(crate) snapshot: Snapshot<D, G>,
    pub(crate) root: Node,
    pub(crate) carrier: Location,
    pub(crate) cms_root: CmsNode,
    pub(crate) cms: Snapshot<DocumentId<'m, 'd>, ()>,
}

impl<D: Copy, G: Copy> Mapping<'_, '_, D, G> {
    pub(crate) fn node(self, member: CmsNode) -> Node {
        if member == self.cms_root {
            self.root
        } else {
            Node::inside(self.carrier, member)
        }
    }
}

impl<'m, 'd, D: Copy + Eq, G: Copy + Eq> Mapping<'m, 'd, D, G> {
    pub(crate) fn actor<'p>(
        self,
        actor: CheckedActor<'p, 'd, CmsNode, DocumentId<'m, 'd>, (), Cades>,
        work: &impl Work,
    ) -> crate::Result<CheckedActor<'p, 'd, Node, D, G, Pades>> {
        admit(work, self.carrier, 1)?;
        let original = actor.verified();
        if original.token().snapshot != self.cms {
            return Err(Error {
                kind: ErrorKind::Foreign,
                location: self.carrier,
            });
        }
        let token = Original {
            snapshot: self.snapshot,
            node: self.node(original.token().node),
        };
        let signature = self.node(original.signature());
        let property = self.node(original.property());
        let purpose = original.purpose();
        let certificate = actor.certificate();
        let key = actor.key();
        let evidence = actor.into_verified().into_evidence();
        Ok(CheckedActor::new(
            ISSUER,
            Verified::new(ISSUER, token, signature, property, purpose, evidence),
            certificate,
            key,
        ))
    }
}