use std::fmt;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use zeroize::{Zeroize, Zeroizing};
use crate::encoding::{decode_hex, encode_hex, Text};
#[derive(Clone, Default)]
pub struct SecretBytes(Zeroizing<Vec<u8>>);
#[derive(Clone, Default)]
pub struct SecretString(Zeroizing<String>);
impl SecretBytes {
pub fn new(bytes: impl Into<Vec<u8>>) -> Self {
Self(Zeroizing::new(bytes.into()))
}
pub fn from_hex(text: &str) -> Result<Self, crate::EncodingError> {
decode_hex(text).map(Self::new)
}
#[must_use]
pub fn expose_secret(&self) -> &[u8] {
&self.0
}
}
impl SecretString {
pub fn new(text: impl Into<String>) -> Self {
Self(Zeroizing::new(text.into()))
}
#[must_use]
pub fn expose_secret(&self) -> &str {
&self.0
}
}
impl From<Vec<u8>> for SecretBytes {
fn from(bytes: Vec<u8>) -> Self {
Self::new(bytes)
}
}
impl From<&[u8]> for SecretBytes {
fn from(bytes: &[u8]) -> Self {
Self::new(bytes.to_vec())
}
}
impl<const N: usize> From<[u8; N]> for SecretBytes {
fn from(mut bytes: [u8; N]) -> Self {
let secret = Self::new(bytes.to_vec());
bytes.zeroize();
secret
}
}
impl From<String> for SecretString {
fn from(text: String) -> Self {
Self::new(text)
}
}
impl From<&str> for SecretString {
fn from(text: &str) -> Self {
Self::new(text)
}
}
impl fmt::Debug for SecretBytes {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("SecretBytes(<redacted>)")
}
}
impl fmt::Debug for SecretString {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("SecretString(<redacted>)")
}
}
impl Serialize for SecretBytes {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let text = Zeroizing::new(encode_hex(&self.0));
serializer.serialize_str(&text)
}
}
impl<'de> Deserialize<'de> for SecretBytes {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
deserializer.deserialize_str(Text(|text: &str| Self::from_hex(text)))
}
}
impl Serialize for SecretString {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(&self.0)
}
}
impl<'de> Deserialize<'de> for SecretString {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
String::deserialize(deserializer).map(Self::new)
}
}
#[cfg(test)]
mod tests;