simple_sign 0.2.0

Simple signing library
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

use std::fmt::Debug;
use std::sync::Arc;

use base_xx::{
    ByteVec, SerialiseError,
    byte_vec::{Encodable, TryIntoByteVec},
    encoded_string::Decodable,
};

use crate::signing_algorithm::SigningAlgorithm;

/// A cryptographic signature along with its associated signing algorithm.
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct Signature {
    algorithm: SigningAlgorithm,
    signature: Arc<ByteVec>,
}

impl Default for Signature {
    fn default() -> Self {
        Self {
            algorithm: SigningAlgorithm::ED25519,
            signature: Arc::new(ByteVec::new(Arc::new(vec![0u8; 64]))),
        }
    }
}

impl Signature {
    #[must_use]
    /// Creates a new Ed25519 signature wrapper from raw signature bytes.
    pub const fn new(signature: Arc<ByteVec>) -> Self {
        Self {
            algorithm: SigningAlgorithm::ED25519,
            signature,
        }
    }

    #[must_use]
    /// Creates a new signature wrapper from raw signature bytes and an explicit algorithm.
    pub const fn new_with_algorithm(algorithm: SigningAlgorithm, signature: Arc<ByteVec>) -> Self {
        Self {
            algorithm,
            signature,
        }
    }

    #[must_use]
    /// Returns the raw signature bytes.
    pub fn get_signature(&self) -> Arc<ByteVec> {
        Arc::clone(&self.signature)
    }

    #[must_use]
    /// Returns the algorithm used for this signature.
    pub const fn get_algorithm(&self) -> SigningAlgorithm {
        self.algorithm
    }
}

impl TryIntoByteVec for Signature {
    fn try_into_byte_vec(value: Arc<Self>) -> Result<Arc<ByteVec>, SerialiseError> {
        let algorithm: u8 = value.get_algorithm().into();
        let mut bytes = vec![algorithm];
        bytes.extend_from_slice(value.get_signature().get_bytes());
        Ok(Arc::new(ByteVec::new(Arc::new(bytes))))
    }
}

impl TryFrom<Arc<ByteVec>> for Signature {
    type Error = SerialiseError;
    fn try_from(value: Arc<ByteVec>) -> Result<Self, Self::Error> {
        match SigningAlgorithm::try_from(value.get_bytes()[0]) {
            Ok(algorithm) => {
                let bytes = value.get_bytes()[1..].to_vec();
                Ok(Self::new_with_algorithm(
                    algorithm,
                    Arc::new(ByteVec::new(Arc::new(bytes))),
                ))
            }
            Err(e) => Err(e),
        }
    }
}

impl Encodable for Signature {}
impl Decodable for Signature {}