dmsg_protocol 0.4.0

Deterministic encoding, COSE document verification, and approval helpers for dMsg
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

//! Run with `cargo bench -p dmsg_protocol --bench validation --locked`.
use std::{hint::black_box, time::Instant};

use dmsg_protocol::*;
use dmsg_types::{user::*, *};
use ed25519_dalek::{Signer, SigningKey};

fn measure(name: &str, iterations: u32, mut run: impl FnMut()) {
    for _ in 0..100 {
        run();
    }
    let mut samples = [0; 7];
    for sample in &mut samples {
        let start = Instant::now();
        for _ in 0..iterations {
            run();
        }
        *sample = start.elapsed().as_nanos() / u128::from(iterations);
    }
    samples.sort_unstable();
    println!("{name}: {} ns/op (median of 7 samples)", samples[3]);
}

fn main() {
    let namespace = "https://dmsg.test/u/";
    let account = AccountId([1; 12]);
    let issuer = account_issuer(namespace, &account);
    let signer = SigningKey::from_bytes(&[7; 32]);
    let statement = Statement {
        issuer: issuer.clone(),
        subject: Some("release/spec".into()),
        issued_at: Some(1_800_000_000),
        content: StatementContent::Text("document".repeat(512)),
    };
    let prepared =
        prepare_attestation(&statement, &Hash::new(signer.verifying_key().to_bytes())).unwrap();
    let tbs = prepared.to_be_signed.clone();
    let signature = signer.sign(&tbs).to_bytes();
    let artifact = prepared.finish(&signature).unwrap();
    let receipt = ExecutionReceipt {
        schema: 2,
        account_id: account,
        issuer: issuer.clone(),
        request_id: Hash::new([2; 32]),
        device_id: Hash::new([3; 32]),
        security_epoch: 1,
        approved_at: 10,
        expires_at: 20,
        origin: "https://app.test".into(),
        to_be_signed_digest: sha256(&tbs),
        public_key_fingerprint: key_thumbprint(&artifact.cose_key).unwrap(),
        signature_digest: signature_digest(&artifact.cose_sign1).unwrap(),
    };
    let device = DeviceInput {
        device_id: Hash::new([3; 32]),
        signing_pub: signer.verifying_key().to_bytes().into(),
        hpke_pub: Hash::new([4; 32]),
        role: ControllerRole::Administrator,
        capabilities: vec![Capability::ContentSign, Capability::FormalApprove],
    };
    measure("mul_div_fee", 100_000, || {
        black_box(
            dmsg_protocol::billing::delivery_service_fee(
                black_box(1_000_001),
                black_box(&dmsg_types::payment::DeliveryFeePolicy {
                    version: 1,
                    effective_at_ms: 0,
                    rate_bps: 500,
                    minimum_atomic: 20_000,
                }),
            )
            .unwrap(),
        );
    });
    measure("account_issuer", 10_000, || {
        black_box(account_issuer(black_box(namespace), black_box(&account)));
    });
    measure("prepare_attestation", 1_000, || {
        black_box(
            prepare_attestation(
                black_box(&statement),
                &Hash::new(signer.verifying_key().to_bytes()),
            )
            .unwrap(),
        );
    });
    measure("match_execution_receipt", 1_000, || {
        match_execution_receipt(black_box(&artifact), black_box(&receipt)).unwrap();
    });
    measure("verify_artifact", 1_000, || {
        black_box(verify_artifact(black_box(&artifact)).unwrap());
    });
    measure("device_validation", 10_000, || {
        black_box(&device).validate().unwrap();
    });
}