prns-core 0.3.4

Pure Reticulum engine and wire contract for Personal Reticulum
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

use super::delivery::DeliveryIo;
use crate::crypto::X25519SharedSecret;
use crate::engine::{DecryptOwed, EngineReaction, EngineState, RatchetDecryptOwed};
use crate::identity::{decrypt_finish_in_place, OpenedBy, OpenedToken};
use crate::interfaces::AttachedInterfaces;
use crate::routing::delivery::{Delivery, SingleDelivery};
use crate::routing::proof::{DeferredProofSign, ProofObligation, ProofOwed, ProofRequest};
use crate::storage::StorageLayout;

impl<S: StorageLayout> EngineState<S> {
    pub fn resume_decrypt(
        &mut self,
        owed: DecryptOwed,
        shared: X25519SharedSecret,
        interfaces: AttachedInterfaces<'_>,
        should_prove: &mut impl FnMut(&ProofRequest) -> bool,
        deferred_sign: &mut Option<DeferredProofSign>,
        sink: &mut impl FnMut(EngineReaction<'_>),
    ) {
        let DecryptOwed {
            destination,
            context,
            arrived_at,
            source_interface,
            identity,
            proof_strategy,
            packet_hash,
            mut token,
            ..
        } = owed;
        let Ok(plaintext) = decrypt_finish_in_place(&shared, &identity, &mut token) else {
            return;
        };
        let proof = ProofObligation::for_delivery(
            proof_strategy,
            ProofOwed {
                packet_hash,
                identity,
            },
        );
        let delivery = Delivery::Single(SingleDelivery {
            destination,
            context,
            plaintext,
            opened_by: OpenedBy::IdentityKey,
            arrived_at,
            source_interface,
        });
        self.process_delivery(
            delivery,
            proof,
            source_interface,
            arrived_at,
            &mut DeliveryIo {
                interfaces,
                should_prove: &mut *should_prove,
                deferred_sign: &mut *deferred_sign,
                sink: &mut *sink,
            },
        );
    }

    pub fn resume_ratchet_decrypt(
        &mut self,
        owed: RatchetDecryptOwed,
        opened: OpenedToken<'_>,
        interfaces: AttachedInterfaces<'_>,
        should_prove: &mut impl FnMut(&ProofRequest) -> bool,
        deferred_sign: &mut Option<DeferredProofSign>,
        sink: &mut impl FnMut(EngineReaction<'_>),
    ) {
        let proof = ProofObligation::for_delivery(
            owed.proof_strategy,
            ProofOwed {
                packet_hash: owed.packet_hash,
                identity: owed.identity,
            },
        );
        let delivery = Delivery::Single(SingleDelivery {
            destination: owed.destination,
            context: owed.context,
            plaintext: opened.plaintext,
            opened_by: opened.opened_by,
            arrived_at: owed.arrived_at,
            source_interface: owed.source_interface,
        });
        self.process_delivery(
            delivery,
            proof,
            owed.source_interface,
            owed.arrived_at,
            &mut DeliveryIo {
                interfaces,
                should_prove: &mut *should_prove,
                deferred_sign: &mut *deferred_sign,
                sink: &mut *sink,
            },
        );
    }
}