foundation-urtypes 0.5.0

Uniform Resource (UR) types. This crate provides a collection of Uniform Resources types that can serialized and deserialized.
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

// SPDX-FileCopyrightText: © 2023 Foundation Devices, Inc. <hello@foundationdevices.com>
// SPDX-License-Identifier: GPL-3.0-or-later

use minicbor::{Decode, Encode};

use crate::cbor::Timestamp;

/// Cryptographic Seed.
#[doc(alias("seed"))]
#[derive(Debug, Decode, Encode)]
pub struct Seed<'a> {
    /// Seed entropy.
    #[cbor(n(0), with = "payload")]
    pub payload: &'a [u8],
    /// Creation date.
    #[cbor(n(1))]
    pub creation_date: Option<Timestamp>,
    /// Short name for the seed.
    #[cbor(n(2))]
    pub name: Option<&'a str>,
    /// Description of the seed.
    #[cbor(n(3))]
    pub note: Option<&'a str>,
}

/// CBOR decoding and encoding of `crypto-seed-digest`.
#[doc(alias("crypto-seed-digest"))]
pub mod digest {
    use minicbor::data::Tag;
    use minicbor::encode::Write;
    use minicbor::{Decoder, Encoder};

    /// Tag representing a `crypto-seed-digest`.
    pub const TAG: Tag = Tag::new(600);

    /// Encode a `crypto-seed-digest`.
    #[doc(alias("crypto-seed-digest"))]
    pub fn encode<C, W: Write>(
        seed_digest: &[u8; 32],
        e: &mut Encoder<W>,
        _ctx: &mut C,
    ) -> Result<(), minicbor::encode::Error<W::Error>> {
        e.tag(TAG)?.bytes(seed_digest)?;
        Ok(())
    }

    /// Decode a `crypto-seed-digest`.
    #[doc(alias("crypto-seed-digest"))]
    pub fn decode<C>(d: &mut Decoder, _ctx: &mut C) -> Result<[u8; 32], minicbor::decode::Error> {
        if d.tag()? != TAG {
            return Err(minicbor::decode::Error::message(
                "invalid crypto-seed-digest tag",
            ));
        };

        let seed_digest = d.bytes()?;
        if seed_digest.len() != 32 {
            return Err(minicbor::decode::Error::message(
                "invalid crypto-seed-digest length",
            ));
        }

        let mut buf = [0u8; 32];
        buf.copy_from_slice(seed_digest);
        Ok(buf)
    }
}

mod payload {
    use minicbor::encode::Write;
    use minicbor::{Decoder, Encoder};

    pub fn encode<C, W: Write>(
        payload: &[u8],
        e: &mut Encoder<W>,
        _ctx: &mut C,
    ) -> Result<(), minicbor::encode::Error<W::Error>> {
        if !(1..=64).contains(&payload.len()) {
            return Err(minicbor::encode::Error::message("invalid seed payload"));
        }

        e.bytes(payload)?;

        Ok(())
    }

    pub fn decode<'b, C>(
        d: &mut Decoder<'b>,
        _ctx: &mut C,
    ) -> Result<&'b [u8], minicbor::decode::Error> {
        let payload = d.bytes()?;

        if !(1..=64).contains(&payload.len()) {
            return Err(minicbor::decode::Error::message(
                "invalid crypto-seed-digest length",
            ));
        }

        Ok(payload)
    }
}