csv-rs 0.1.0

Library for HYGON CSV and DCU
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

// Copyright (C) Hygon Info Technologies Ltd.
//
// SPDX-License-Identifier: Apache-2.0

//! Operations that can be done on a Certificate Authority chain.

use crate::{
    certs::{Algorithm, Usage, Verifiable},
    crypto::{key::ecc, sig::ecdsa, PublicKey, Signature},
    util::*,
};

use serde::{Deserialize, Serialize};
use serde_big_array::BigArray;
use std::io::{Error, ErrorKind, Read, Result, Write};

#[repr(C)]
#[derive(Copy, Clone, Serialize, Deserialize)]
pub struct Data {
    pub kid: [u8; 16],
    pub sid: [u8; 16],
    pub usage: Usage,
    pub reserved: [u8; 24],
}

#[repr(C)]
#[derive(Copy, Clone, Serialize, Deserialize)]
pub struct Preamble {
    pub ver: u32,
    pub data: Data,
}

#[repr(C)]
#[derive(Copy, Clone, Serialize, Deserialize)]
pub struct Body {
    pub preamble: Preamble,
    pub pubkey: ecc::PubKey,
    pub uid_size: u16,
    #[serde(with = "BigArray")]
    pub user_id: [u8; 254],
    #[serde(with = "BigArray")]
    pub reserved: [u8; 108],
}

/// A Certificate Authority chain.
#[repr(C)]
#[derive(Copy, Clone, Serialize, Deserialize)]
pub struct Certificate {
    pub body: Body,
    signature: ecdsa::Signature,
    #[serde(with = "BigArray")]
    _reserved: [u8; 112],
}

impl Certificate {
    /// Writes the certificate content to a file.
    pub fn write_to_file(&self, path: &std::path::Path) -> Result<()> {
        let mut file = std::fs::File::create(path)?;
        let encoded = bincode::serialize(self).map_err(|e| Error::new(ErrorKind::Other, e))?;
        file.write_all(&encoded)?;
        Ok(())
    }
}

impl TryFrom<&Certificate> for Signature {
    type Error = Error;

    #[inline]
    fn try_from(value: &Certificate) -> Result<Self> {
        let sig = Vec::try_from(&value.signature)?;
        Ok(Self {
            sig,
            id: Some(value.body.preamble.data.sid),
            usage: Usage::HRK,
            algo: None,
        })
    }
}

impl TryFrom<&Certificate> for PublicKey {
    type Error = Error;

    #[inline]
    fn try_from(value: &Certificate) -> Result<Self> {
        let key = value.body.pubkey;
        Ok(Self {
            id: Some(value.body.preamble.data.kid),
            key,
            usage: value.body.preamble.data.usage,
            algo: Some(Algorithm::SM2_SA),
        })
    }
}

impl TryFrom<&Certificate> for Usage {
    type Error = Error;

    fn try_from(value: &Certificate) -> Result<Self> {
        Ok(value.body.preamble.data.usage)
    }
}

impl codicon::Decoder<()> for Certificate {
    type Error = Error;

    fn decode(mut reader: impl Read, _: ()) -> Result<Self> {
        Ok(Self {
            body: reader.load()?,
            signature: reader.load()?,
            _reserved: reader.load()?,
        })
    }
}

impl codicon::Encoder<crate::Body> for Certificate {
    type Error = Error;

    fn encode(&self, mut writer: impl Write, _: crate::Body) -> Result<()> {
        writer.save(&self.body)
    }
}

impl Verifiable for (&Certificate, &Certificate) {
    type Output = ();

    fn verify(self) -> Result<()> {
        let key: PublicKey = self.0.try_into()?;
        let sig: Signature = self.1.try_into()?;
        key.verify(
            self.1,
            &self.0.body.user_id[..self.0.body.uid_size as usize],
            &sig,
        )
    }
}