omaha: bring back base64 decoding functionality

Since we need to support decoding of both hex and base64 formats, bring
back base64 decoding functionality.

Note, while hash_sha256 of Package has hex format, sha256 of Action has
base64 format. That is the reason why we need to keep both
mod sha256_from_hex_str and mod sha256_from_base64_str.

Signed-off-by: Dongsu Park <[email protected]>

Author: dongsupark

Cargo.lock

@@ -10,6 +10,8 @@ uuid = "1.2"
 url = "2"
 sha2 = "0.10.8"
 sha1 = "0.10.6"
+ct-codecs = "1.1.6"
+log = "0.4.28"
 
 [dependencies.hard-xml]
 path = "../vendor/hard-xml"

omaha/Cargo.toml

@@ -4,6 +4,7 @@ use std::num::ParseIntError;
 #[derive(Debug)]
 pub enum Error {
     TryFromHex(ParseIntError),
+    TryFromBase64(ct_codecs::Error),
     InvalidDigestLength {
         expected: usize,
         actual: usize,
@@ -19,6 +20,7 @@ impl Display for Error {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Error::TryFromHex(err) => write!(fmt, "failed to convert from hex: {err}"),
+            Error::TryFromBase64(err) => write!(fmt, "failed to convert from base64: {err}"),
             Error::InvalidDigestLength {
                 expected,
                 actual,

omaha/src/error.rs

@@ -1,4 +1,5 @@
 use std::str;
+use ct_codecs::{Base64, Decoder};
 
 use sha2::Digest;
 
@@ -42,8 +43,12 @@ pub trait Hasher {
     fn finalize(self) -> Self::Output;
 
     /// Construct a hash of the output format of the associated hashing
-    /// algorithm using a provided string.
+    /// algorithm using a provided hex string.
     fn try_from_hex_string(s: &str) -> Result<Self::Output>;
+
+    /// Construct a hash of the output format of the associated hashing
+    /// algorithm using a provided base64 string.
+    fn try_from_base64_string(s: &str) -> Result<Self::Output>;
 }
 
 impl Hasher for Sha1 {
@@ -67,6 +72,10 @@ impl Hasher for Sha1 {
     fn try_from_hex_string(s: &str) -> Result<Self::Output> {
         try_from_hex_string::<Self>(s)
     }
+
+    fn try_from_base64_string(s: &str) -> Result<Self::Output> {
+        try_from_base64_string::<Self>(s)
+    }
 }
 
 pub(crate) mod sha1_from_str {
@@ -75,7 +84,7 @@ pub(crate) mod sha1_from_str {
 
     #[inline]
     pub(crate) fn from_str(s: &str) -> Result<Sha1Digest> {
-        <Sha1 as Hasher>::try_from_hex_string(s)
+        <Sha1 as Hasher>::try_from_base64_string(s)
     }
 }
 
@@ -96,12 +105,17 @@ impl Hasher for Sha256 {
     fn finalize(self) -> Self::Output {
         self.0.finalize().into()
     }
+
     fn try_from_hex_string(s: &str) -> Result<Self::Output> {
         try_from_hex_string::<Self>(s)
     }
+
+    fn try_from_base64_string(s: &str) -> Result<Self::Output> {
+        try_from_base64_string::<Self>(s)
+    }
 }
 
-pub(crate) mod sha256_from_str {
+pub(crate) mod sha256_from_hex_str {
     use crate::{Hasher, Sha256, Sha256Digest};
     use crate::Result;
 
@@ -111,6 +125,16 @@ pub(crate) mod sha256_from_str {
     }
 }
 
+pub(crate) mod sha256_from_base64_str {
+    use crate::{Hasher, Sha256, Sha256Digest};
+    use crate::Result;
+
+    #[inline]
+    pub(crate) fn from_str(s: &str) -> Result<Sha256Digest> {
+        <Sha256 as Hasher>::try_from_base64_string(s)
+    }
+}
+
 /// Parse a hexadecimal string into the output of the generically typed hashing
 /// algorithm.
 fn try_from_hex_string<T: Hasher>(s: &str) -> Result<T::Output> {
@@ -136,6 +160,19 @@ fn try_from_hex_string<T: Hasher>(s: &str) -> Result<T::Output> {
     }
 }
 
+/// Parse a base64 string into the output of the generically typed hashing
+/// algorithm.
+fn try_from_base64_string<T: Hasher>(s: &str) -> Result<T::Output> {
+    let mut digest = T::Output::default();
+    let mut bytes = vec![0; s.len()];
+
+    let bytes = Base64::decode(bytes.as_mut(), s, None).map_err(Error::TryFromBase64)?;
+
+    digest.as_mut().copy_from_slice(bytes);
+
+    Ok(digest)
+}
+
 #[cfg(test)]
 mod tests {
     use crate::Hasher;

omaha/src/hash_types.rs

@@ -8,7 +8,7 @@ use url::Url;
 
 use crate::Error::{UnknownActionEvent, UnknownSuccessAction};
 use crate::uuid::braced_uuid;
-use crate::{Sha1Digest, Sha256Digest, Error, sha1_from_str, sha256_from_str};
+use crate::{Sha1Digest, Sha256Digest, Error, sha1_from_str, sha256_from_base64_str, sha256_from_hex_str};
 
 #[derive(XmlRead, Debug)]
 #[xml(tag = "response")]
@@ -159,7 +159,7 @@ pub struct Package<'a> {
     #[xml(attr = "required")]
     pub required: bool,
 
-    #[xml(attr = "hash_sha256", with = "sha256_from_str")]
+    #[xml(attr = "hash_sha256", with = "sha256_from_hex_str")]
     pub hash_sha256: Option<Sha256Digest>,
 }
 
@@ -178,7 +178,7 @@ pub struct Action {
     #[xml(attr = "event")]
     pub event: ActionEvent,
 
-    #[xml(attr = "sha256", with = "sha256_from_str")]
+    #[xml(attr = "sha256", with = "sha256_from_base64_str")]
     pub sha256: Sha256Digest,
 
     #[xml(attr = "DisablePayloadBackoff")]
@@ -333,7 +333,7 @@ mod tests {
     #[test]
     fn package_xml_read_hashes() {
         const NAME: &str = "name";
-        const SHA1_STR: &str = "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d";
+        const SHA1_STR: &str = "FF+ci4cThKAdESIk5GbSgrN0Q7A=";
         const SIZE: usize = 1;
         const REQUIRED: bool = false;
         const SHA256_STR: &str = "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824";
@@ -342,7 +342,7 @@ mod tests {
             format!("<package name=\"{NAME}\" hash=\"{SHA1_STR}\" size=\"{SIZE}\" required=\"{REQUIRED}\" hash_sha256=\"{SHA256_STR}\"/>",).as_str(),
             Package {
                 name: Cow::Borrowed(NAME),
-                hash: Some(Sha1::try_from_hex_string(SHA1_STR).unwrap()),
+                hash: Some(Sha1::try_from_base64_string(SHA1_STR).unwrap()),
                 size: SIZE,
                 required: REQUIRED,
                 hash_sha256: Some(Sha256::try_from_hex_string(SHA256_STR).unwrap()),