coldstar-signer 0.2.0

Secure signing core — AES-256-GCM, Argon2id, Ed25519, secp256k1, ZK proofs, mlock'd memory
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

//! Error types for the secure signer
//!
//! All errors are designed to be informative without leaking sensitive data.
//! Merged from coldstar-rs and devsyrem secure_signer implementations.

use thiserror::Error;

/// Errors that can occur during signing operations
#[derive(Debug, Error)]
pub enum SignerError {
    /// Memory locking failed - system may not support mlock or limit reached
    #[error("Failed to lock memory: {0}")]
    MemoryLockFailed(String),

    /// Key derivation failed
    #[error("Key derivation failed: {0}")]
    KeyDerivationFailed(String),

    /// Decryption failed - wrong passphrase or corrupted data
    #[error("Decryption failed - invalid passphrase or corrupted container")]
    DecryptionFailed,

    /// Encryption failed
    #[error("Encryption failed: {0}")]
    EncryptionFailed(String),

    /// Invalid key format (from devsyrem: expected 32 or 64 bytes)
    #[error("Invalid key format: expected 32 or 64 bytes, got {0}")]
    InvalidKeyFormat(usize),

    /// Invalid key length (from coldstar-rs: generic expected vs got)
    #[error("Invalid key length: expected {expected}, got {got}")]
    InvalidKeyLength { expected: usize, got: usize },

    /// Signing operation failed
    #[error("Signing failed: {0}")]
    SigningFailed(String),

    /// Invalid transaction format
    #[error("Invalid transaction format: {0}")]
    InvalidTransaction(String),

    /// Serialization error
    #[error("Serialization error: {0}")]
    SerializationError(String),

    /// Base58 decoding error
    #[error("Base58 decoding error: {0}")]
    Base58Error(String),

    /// Base64 decoding error
    #[error("Base64 decoding error: {0}")]
    Base64Error(String),

    /// Container format error
    #[error("Invalid container format: {0}")]
    ContainerError(String),

    /// I/O error
    #[error("I/O error: {0}")]
    IoError(String),
}

impl From<std::io::Error> for SignerError {
    fn from(e: std::io::Error) -> Self {
        SignerError::IoError(e.to_string())
    }
}

impl From<base64::DecodeError> for SignerError {
    fn from(e: base64::DecodeError) -> Self {
        SignerError::Base64Error(e.to_string())
    }
}

impl From<bs58::decode::Error> for SignerError {
    fn from(e: bs58::decode::Error) -> Self {
        SignerError::Base58Error(e.to_string())
    }
}

impl From<serde_json::Error> for SignerError {
    fn from(e: serde_json::Error) -> Self {
        SignerError::SerializationError(e.to_string())
    }
}