use crate::{Error, LockboxOptions, LockboxProtection, OwnerSigningKeyPair, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ZstdLevel(u8);
impl ZstdLevel {
pub fn new(level: u8) -> Result<Self> {
if (1..=22).contains(&level) {
Ok(Self(level))
} else {
Err(Error::InvalidInput(
"Zstd level must be between 1 and 22".into(),
))
}
}
pub const fn get(self) -> u8 {
self.0
}
}
impl Default for ZstdLevel {
fn default() -> Self {
Self(3)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Compression {
None,
Zstd {
level: ZstdLevel,
},
}
impl Default for Compression {
fn default() -> Self {
Self::Zstd {
level: ZstdLevel::default(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EncryptionMode {
None,
ChaCha20Poly1305,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SigningMode {
None,
Owner,
}
pub enum Encryption<'a> {
None,
Encrypted(LockboxProtection<'a>),
}
#[derive(Clone, Copy)]
pub enum Signing<'a> {
None,
Owner(&'a OwnerSigningKeyPair),
}
impl<'a> From<&'a OwnerSigningKeyPair> for Signing<'a> {
fn from(key: &'a OwnerSigningKeyPair) -> Self {
Self::Owner(key)
}
}
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub enum SizePadding {
#[default]
Default,
None,
}
pub struct LockboxCreateOptions<'a> {
pub encryption: Encryption<'a>,
pub signing: Signing<'a>,
pub compression: Compression,
pub size_padding: SizePadding,
pub runtime: LockboxOptions,
}
impl<'a> LockboxCreateOptions<'a> {
pub fn new(encryption: Encryption<'a>, signing: Signing<'a>) -> Self {
Self {
encryption,
signing,
compression: Compression::default(),
size_padding: SizePadding::default(),
runtime: LockboxOptions::default(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct LockboxFormatOptions {
pub encryption: EncryptionMode,
pub signing: SigningMode,
pub compression: Compression,
pub size_padding: SizePadding,
}
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub(crate) struct FormatMode(pub(crate) u16);
impl FormatMode {
pub(crate) fn new(options: LockboxFormatOptions) -> Self {
let bits = (u16::from(options.size_padding == SizePadding::None) << 8)
| u16::from(options.encryption == EncryptionMode::None)
| (u16::from(options.signing == SigningMode::None) << 1)
| match options.compression {
Compression::None => 4,
Compression::Zstd { level } => u16::from(level.get()) << 3,
};
Self(bits)
}
pub(crate) fn parse(bits: u16) -> Result<Self> {
let encoding = bits & 0xff;
if bits & !0x1ff != 0
|| (bits != 0
&& (encoding == 0
|| if encoding & 4 != 0 {
encoding >> 3 != 0
} else {
!(1..=22).contains(&(encoding >> 3))
}))
{
return Err(Error::CorruptHeader);
}
Ok(Self(bits))
}
pub(crate) fn plaintext(self) -> bool {
self.0 & 1 != 0
}
pub(crate) fn unpadded(self) -> bool {
self.0 & 0x100 != 0
}
pub(crate) fn signed(self) -> bool {
self.0 & 2 == 0
}
pub(crate) fn options(self) -> LockboxFormatOptions {
LockboxFormatOptions {
size_padding: if self.unpadded() {
SizePadding::None
} else {
SizePadding::Default
},
encryption: if self.plaintext() {
EncryptionMode::None
} else {
EncryptionMode::ChaCha20Poly1305
},
signing: if self.signed() {
SigningMode::Owner
} else {
SigningMode::None
},
compression: if self.0 & 4 != 0 {
Compression::None
} else {
Compression::Zstd {
level: ZstdLevel(if self.0 == 0 {
1
} else {
((self.0 & 0xff) >> 3) as u8
}),
}
},
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn padding_bit_does_not_alias_codec_levels_or_legacy_mode() {
for encryption in [EncryptionMode::None, EncryptionMode::ChaCha20Poly1305] {
for signing in [SigningMode::None, SigningMode::Owner] {
for size_padding in [SizePadding::Default, SizePadding::None] {
for compression in
std::iter::once(Compression::None).chain((1..=22).map(|level| {
Compression::Zstd {
level: ZstdLevel::new(level).unwrap(),
}
}))
{
let options = LockboxFormatOptions {
encryption,
signing,
compression,
size_padding,
};
let mode = FormatMode::new(options);
assert_eq!(FormatMode::parse(mode.0).unwrap().options(), options);
assert!(FormatMode::parse(mode.0 | 0x200).is_err());
}
}
}
}
assert_eq!(
FormatMode::parse(0).unwrap().options().size_padding,
SizePadding::Default
);
assert!(
FormatMode::parse(0x100).is_err(),
"do not create a second legacy encoding"
);
}
#[test]
fn content_pages_must_match_the_archive_padding_policy() {
use crate::page::{PageObject, PageObjectKind};
let objects = [PageObject::new(PageObjectKind::FileData, 1, vec![7; 29])];
let mut options = LockboxFormatOptions {
encryption: EncryptionMode::None,
signing: SigningMode::None,
compression: Compression::None,
size_padding: SizePadding::Default,
};
let padded = FormatMode::new(options);
options.size_padding = SizePadding::None;
let compact = FormatMode::new(options);
let id = crate::LockboxId::from_bytes([5; 16]);
for mode in [padded, compact] {
let len =
crate::page::page_size_for_encoded_objects_with_format(&objects, mode).unwrap();
let bytes =
crate::page::encode_page_with_format(len, id, 1, 1, &[], &objects, mode).unwrap();
assert!(crate::page::decode_page_with_format(&bytes, id, &[], mode).is_ok());
assert!(crate::page::decode_page_with_format(
&bytes,
id,
&[],
if mode == padded { compact } else { padded }
)
.is_err());
}
}
}