blob: 8d358253b384f1cccd89a916e2a419a2f9eec835 [file] [log] [blame]
// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use {
crate::errors::{BlobIdParseError, CupMissingField},
fidl_fuchsia_pkg as fidl,
proptest_derive::Arbitrary,
serde::{Deserialize, Serialize},
std::{convert::TryFrom, fmt, str},
typed_builder::TypedBuilder,
};
pub(crate) const BLOB_ID_SIZE: usize = 32;
/// Convenience wrapper type for the autogenerated FIDL `BlobId`.
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize, Arbitrary)]
pub struct BlobId(#[serde(with = "hex_serde")] [u8; BLOB_ID_SIZE]);
impl BlobId {
/// Parse a `BlobId` from a string containing 32 lower-case hex encoded bytes.
///
/// # Examples
/// ```
/// let s = "00112233445566778899aabbccddeeffffeeddccbbaa99887766554433221100";
/// assert_eq!(
/// BlobId::parse(s),
/// s.parse()
/// );
/// ```
pub fn parse(s: &str) -> Result<Self, BlobIdParseError> {
s.parse()
}
/// Obtain a slice of bytes representing the `BlobId`.
pub fn as_bytes(&self) -> &[u8] {
&self.0[..]
}
}
impl str::FromStr for BlobId {
type Err = BlobIdParseError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let bytes = hex::decode(s)?;
if bytes.len() != BLOB_ID_SIZE {
return Err(BlobIdParseError::InvalidLength(bytes.len()));
}
if s.chars().any(|c| c.is_uppercase()) {
return Err(BlobIdParseError::CannotContainUppercase);
}
let mut res: [u8; BLOB_ID_SIZE] = [0; BLOB_ID_SIZE];
res.copy_from_slice(&bytes[..]);
Ok(Self(res))
}
}
impl From<[u8; BLOB_ID_SIZE]> for BlobId {
fn from(bytes: [u8; BLOB_ID_SIZE]) -> Self {
Self(bytes)
}
}
impl From<fidl::BlobId> for BlobId {
fn from(id: fidl::BlobId) -> Self {
Self(id.merkle_root)
}
}
impl From<BlobId> for fidl::BlobId {
fn from(id: BlobId) -> Self {
Self { merkle_root: id.0 }
}
}
impl From<fuchsia_hash::Hash> for BlobId {
fn from(hash: fuchsia_hash::Hash) -> Self {
Self(hash.into())
}
}
impl From<BlobId> for fuchsia_hash::Hash {
fn from(id: BlobId) -> Self {
id.0.into()
}
}
impl fmt::Display for BlobId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&hex::encode(self.0))
}
}
impl fmt::Debug for BlobId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.to_string())
}
}
/// Convenience wrapper type for the autogenerated FIDL `BlobInfo`.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Arbitrary)]
pub struct BlobInfo {
pub blob_id: BlobId,
pub length: u64,
}
impl BlobInfo {
pub fn new(blob_id: BlobId, length: u64) -> Self {
BlobInfo { blob_id: blob_id, length: length }
}
}
impl From<fidl::BlobInfo> for BlobInfo {
fn from(info: fidl::BlobInfo) -> Self {
BlobInfo { blob_id: info.blob_id.into(), length: info.length }
}
}
impl From<BlobInfo> for fidl::BlobInfo {
fn from(info: BlobInfo) -> Self {
Self { blob_id: info.blob_id.into(), length: info.length }
}
}
mod hex_serde {
use {super::BLOB_ID_SIZE, hex::FromHex, serde::Deserialize};
pub fn serialize<S>(bytes: &[u8; BLOB_ID_SIZE], serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let s = hex::encode(bytes);
serializer.serialize_str(&s)
}
pub fn deserialize<'de, D>(deserializer: D) -> Result<[u8; BLOB_ID_SIZE], D::Error>
where
D: serde::Deserializer<'de>,
{
let value = String::deserialize(deserializer)?;
<[u8; BLOB_ID_SIZE]>::from_hex(value.as_bytes())
.map_err(|e| serde::de::Error::custom(format!("bad hex value: {:?}: {}", value, e)))
}
}
#[derive(Clone, Debug, Eq, PartialEq, TypedBuilder)]
pub struct CupData {
#[builder(default, setter(into))]
pub request: Vec<u8>,
#[builder(default, setter(into))]
pub key_id: u64,
#[builder(default, setter(into))]
pub nonce: [u8; 32],
#[builder(default, setter(into))]
pub response: Vec<u8>,
#[builder(default, setter(into))]
pub signature: Vec<u8>,
}
impl From<CupData> for fidl::CupData {
fn from(c: CupData) -> Self {
fidl::CupData {
request: Some(c.request),
key_id: Some(c.key_id),
nonce: Some(c.nonce),
response: Some(c.response),
signature: Some(c.signature),
..fidl::CupData::EMPTY
}
}
}
impl TryFrom<fidl::CupData> for CupData {
type Error = CupMissingField;
fn try_from(c: fidl::CupData) -> Result<Self, Self::Error> {
Ok(CupData::builder()
.request(c.request.ok_or(CupMissingField::Request)?)
.response(c.response.ok_or(CupMissingField::Response)?)
.key_id(c.key_id.ok_or(CupMissingField::KeyId)?)
.nonce(c.nonce.ok_or(CupMissingField::Nonce)?)
.signature(c.signature.ok_or(CupMissingField::Signature)?)
.build())
}
}
#[cfg(test)]
mod tests {
use super::*;
use proptest::prelude::*;
prop_compose! {
fn invalid_hex_char()(c in "[[:ascii:]&&[^0-9a-fA-F]]") -> char {
assert_eq!(c.len(), 1);
c.chars().next().unwrap()
}
}
proptest! {
#![proptest_config(ProptestConfig{
// Disable persistence to avoid the warning for not running in the
// source code directory (since we're running on a Fuchsia target)
failure_persistence: None,
.. ProptestConfig::default()
})]
#[test]
fn parse_is_inverse_of_display(ref id in "[0-9a-f]{64}") {
prop_assert_eq!(
id,
&format!("{}", id.parse::<BlobId>().unwrap())
);
}
#[test]
fn parse_is_inverse_of_debug(ref id in "[0-9a-f]{64}") {
prop_assert_eq!(
id,
&format!("{:?}", id.parse::<BlobId>().unwrap())
);
}
#[test]
fn parse_rejects_uppercase(ref id in "[0-9A-F]{64}") {
prop_assert_eq!(
id.parse::<BlobId>(),
Err(BlobIdParseError::CannotContainUppercase)
);
}
#[test]
fn parse_rejects_unexpected_characters(mut id in "[0-9a-f]{64}", c in invalid_hex_char(), index in 0usize..63) {
id.remove(index);
id.insert(index, c);
prop_assert_eq!(
id.parse::<BlobId>(),
Err(BlobIdParseError::FromHexError(
hex::FromHexError::InvalidHexCharacter { c: c, index: index }
))
);
}
#[test]
fn parse_expects_even_sized_strings(ref id in "[0-9a-f]([0-9a-f]{2})*") {
prop_assert_eq!(
id.parse::<BlobId>(),
Err(BlobIdParseError::FromHexError(hex::FromHexError::OddLength))
);
}
#[test]
fn parse_expects_precise_count_of_bytes(ref id in "([0-9a-f]{2})*") {
prop_assume!(id.len() != BLOB_ID_SIZE * 2);
prop_assert_eq!(
id.parse::<BlobId>(),
Err(BlobIdParseError::InvalidLength(id.len() / 2))
);
}
#[test]
fn blobid_fidl_conversions_are_inverses(id: BlobId) {
let temp : fidl::BlobId = id.into();
prop_assert_eq!(
id,
BlobId::from(temp)
);
}
}
}