solana_sdk/
signature.rs

1//! The `signature` module provides functionality for public, and private keys.
2#![cfg(feature = "full")]
3
4// legacy module paths
5pub use crate::signer::{keypair::*, null_signer::*, presigner::*, *};
6use {
7    crate::pubkey::Pubkey,
8    generic_array::{typenum::U64, GenericArray},
9    std::{
10        borrow::{Borrow, Cow},
11        convert::TryInto,
12        fmt, mem,
13        str::FromStr,
14    },
15    thiserror::Error,
16};
17
18/// Number of bytes in a signature
19pub const SIGNATURE_BYTES: usize = 64;
20/// Maximum string length of a base58 encoded signature
21const MAX_BASE58_SIGNATURE_LEN: usize = 88;
22
23#[repr(transparent)]
24#[derive(
25    Serialize, Deserialize, Clone, Copy, Default, Eq, PartialEq, Ord, PartialOrd, Hash, AbiExample,
26)]
27pub struct Signature(GenericArray<u8, U64>);
28
29impl crate::sanitize::Sanitize for Signature {}
30
31impl Signature {
32    pub fn new(signature_slice: &[u8]) -> Self {
33        Self(GenericArray::clone_from_slice(signature_slice))
34    }
35
36    pub fn new_unique() -> Self {
37        let random_bytes: Vec<u8> = (0..64).map(|_| rand::random::<u8>()).collect();
38        Self::new(&random_bytes)
39    }
40
41    pub(self) fn verify_verbose(
42        &self,
43        pubkey_bytes: &[u8],
44        message_bytes: &[u8],
45    ) -> Result<(), ed25519_dalek::SignatureError> {
46        let publickey = ed25519_dalek::PublicKey::from_bytes(pubkey_bytes)?;
47        let signature = self.0.as_slice().try_into()?;
48        publickey.verify_strict(message_bytes, &signature)
49    }
50
51    pub fn verify(&self, pubkey_bytes: &[u8], message_bytes: &[u8]) -> bool {
52        self.verify_verbose(pubkey_bytes, message_bytes).is_ok()
53    }
54}
55
56pub trait Signable {
57    fn sign(&mut self, keypair: &Keypair) {
58        let signature = keypair.sign_message(self.signable_data().borrow());
59        self.set_signature(signature);
60    }
61    fn verify(&self) -> bool {
62        self.get_signature()
63            .verify(self.pubkey().as_ref(), self.signable_data().borrow())
64    }
65
66    fn pubkey(&self) -> Pubkey;
67    fn signable_data(&self) -> Cow<[u8]>;
68    fn get_signature(&self) -> Signature;
69    fn set_signature(&mut self, signature: Signature);
70}
71
72impl AsRef<[u8]> for Signature {
73    fn as_ref(&self) -> &[u8] {
74        &self.0[..]
75    }
76}
77
78impl fmt::Debug for Signature {
79    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
80        write!(f, "{}", bs58::encode(self.0).into_string())
81    }
82}
83
84impl fmt::Display for Signature {
85    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
86        write!(f, "{}", bs58::encode(self.0).into_string())
87    }
88}
89
90impl From<Signature> for [u8; 64] {
91    fn from(signature: Signature) -> Self {
92        signature.0.into()
93    }
94}
95
96#[derive(Debug, Clone, PartialEq, Eq, Error)]
97pub enum ParseSignatureError {
98    #[error("string decoded to wrong size for signature")]
99    WrongSize,
100    #[error("failed to decode string to signature")]
101    Invalid,
102}
103
104impl FromStr for Signature {
105    type Err = ParseSignatureError;
106
107    fn from_str(s: &str) -> Result<Self, Self::Err> {
108        if s.len() > MAX_BASE58_SIGNATURE_LEN {
109            return Err(ParseSignatureError::WrongSize);
110        }
111        let bytes = bs58::decode(s)
112            .into_vec()
113            .map_err(|_| ParseSignatureError::Invalid)?;
114        if bytes.len() != mem::size_of::<Signature>() {
115            Err(ParseSignatureError::WrongSize)
116        } else {
117            Ok(Signature::new(&bytes))
118        }
119    }
120}
121
122#[cfg(test)]
123mod tests {
124    use super::*;
125    #[test]
126    fn test_signature_fromstr() {
127        let signature = Keypair::new().sign_message(&[0u8]);
128
129        let mut signature_base58_str = bs58::encode(signature).into_string();
130
131        assert_eq!(signature_base58_str.parse::<Signature>(), Ok(signature));
132
133        signature_base58_str.push_str(&bs58::encode(signature.0).into_string());
134        assert_eq!(
135            signature_base58_str.parse::<Signature>(),
136            Err(ParseSignatureError::WrongSize)
137        );
138
139        signature_base58_str.truncate(signature_base58_str.len() / 2);
140        assert_eq!(signature_base58_str.parse::<Signature>(), Ok(signature));
141
142        signature_base58_str.truncate(signature_base58_str.len() / 2);
143        assert_eq!(
144            signature_base58_str.parse::<Signature>(),
145            Err(ParseSignatureError::WrongSize)
146        );
147
148        let mut signature_base58_str = bs58::encode(signature.0).into_string();
149        assert_eq!(signature_base58_str.parse::<Signature>(), Ok(signature));
150
151        // throw some non-base58 stuff in there
152        signature_base58_str.replace_range(..1, "I");
153        assert_eq!(
154            signature_base58_str.parse::<Signature>(),
155            Err(ParseSignatureError::Invalid)
156        );
157
158        // too long input string
159        // longest valid encoding
160        let mut too_long = bs58::encode(&[255u8; SIGNATURE_BYTES]).into_string();
161        // and one to grow on
162        too_long.push('1');
163        assert_eq!(
164            too_long.parse::<Signature>(),
165            Err(ParseSignatureError::WrongSize)
166        );
167    }
168
169    #[test]
170    fn test_off_curve_pubkey_verify_fails() {
171        // Golden point off the ed25519 curve
172        let off_curve_bytes = bs58::decode("9z5nJyQar1FUxVJxpBXzon6kHehbomeYiDaLi9WAMhCq")
173            .into_vec()
174            .unwrap();
175
176        // Confirm golden's off-curvedness
177        let mut off_curve_bits = [0u8; 32];
178        off_curve_bits.copy_from_slice(&off_curve_bytes);
179        let off_curve_point = curve25519_dalek::edwards::CompressedEdwardsY(off_curve_bits);
180        assert_eq!(off_curve_point.decompress(), None);
181
182        let pubkey = Pubkey::try_from(off_curve_bytes).unwrap();
183        let signature = Signature::default();
184        // Unfortunately, ed25519-dalek doesn't surface the internal error types that we'd ideally
185        // `source()` out of the `SignatureError` returned by `verify_strict()`.  So the best we
186        // can do is `is_err()` here.
187        assert!(signature.verify_verbose(pubkey.as_ref(), &[0u8]).is_err());
188    }
189}
solana_sdk/signature.rs

solana_sdk/
signature.rs
