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,7 @@ uuid = "1.2"
 url = "2"
 sha2 = "0.10.8"
 sha1 = "0.10.6"
+ct-codecs = "1.1.6"
 
 [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,15 +72,19 @@ 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 {
+pub(crate) mod sha1_from_base64_str {
     use crate::{Hasher, Sha1, Sha1Digest};
     use crate::Result;
 
     #[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,10 +160,29 @@ 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 bytes = vec![0; s.len()];
+
+    let bytes = Base64::decode(bytes.as_mut(), s, None).map_err(Error::TryFromBase64)?;
+
+    if bytes.len() == T::FINGERPRINT_SIZE {
+        let mut digest = T::Output::default();
+        digest.as_mut().copy_from_slice(bytes);
+        Ok(digest)
+    } else {
+        Err(Error::InvalidDigestLength {
+            expected: T::FINGERPRINT_SIZE,
+            actual: bytes.len(),
+        })
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::Hasher;
-    use super::{Sha256, Sha1, try_from_hex_string};
+    use super::{Sha256, Sha1, try_from_hex_string, try_from_base64_string};
     use sha1::Digest;
 
     const TEST_DATA: &[u8] = b"test string";
@@ -197,4 +240,25 @@ mod tests {
         assert!(sha256_digest.is_ok());
         assert_eq!(sha256_digest.unwrap(), exp_bytes);
     }
+
+    #[test]
+    fn try_from_base64_string_sha1() {
+        let base64_string = "FF+ci4cThKAdESIk5GbSgrN0Q7A=";
+        let exp_bytes = [20, 95, 156, 139, 135, 19, 132, 160, 29, 17, 34, 36, 228, 102, 210, 130, 179, 116, 67, 176];
+        let sha1_digest = try_from_base64_string::<Sha1>(base64_string);
+
+        assert!(sha1_digest.is_ok());
+        assert_eq!(sha1_digest.unwrap(), exp_bytes);
+    }
+
+    #[test]
+    fn try_from_base64_string_sha256() {
+        let base64_string = "LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=";
+
+        let exp_bytes = [44, 242, 77, 186, 95, 176, 163, 14, 38, 232, 59, 42, 197, 185, 226, 158, 27, 22, 30, 92, 31, 167, 66, 94, 115, 4, 51, 98, 147, 139, 152, 36];
+        let sha256_digest = try_from_base64_string::<Sha256>(base64_string);
+
+        assert!(sha256_digest.is_ok());
+        assert_eq!(sha256_digest.unwrap(), &exp_bytes[..]);
+    }
 }

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_base64_str, sha256_from_base64_str, sha256_from_hex_str};
 
 #[derive(XmlRead, Debug)]
 #[xml(tag = "response")]
@@ -150,7 +150,7 @@ pub struct Package<'a> {
     #[xml(attr = "name")]
     pub name: Cow<'a, str>,
 
-    #[xml(attr = "hash", with = "sha1_from_str")]
+    #[xml(attr = "hash", with = "sha1_from_base64_str")]
     pub hash: Option<Sha1Digest>,
 
     #[xml(attr = "size")]
@@ -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,16 +333,16 @@ mod tests {
     #[test]
     fn package_xml_read_hashes() {
         const NAME: &str = "name";
-        const SHA1_STR: &str = "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d";
+        const BASE64_STR: &str = "FF+ci4cThKAdESIk5GbSgrN0Q7A=";
         const SIZE: usize = 1;
         const REQUIRED: bool = false;
         const SHA256_STR: &str = "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824";
 
         test_xml_read(
-            format!("<package name=\"{NAME}\" hash=\"{SHA1_STR}\" size=\"{SIZE}\" required=\"{REQUIRED}\" hash_sha256=\"{SHA256_STR}\"/>",).as_str(),
+            format!("<package name=\"{NAME}\" hash=\"{BASE64_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(BASE64_STR).unwrap()),
                 size: SIZE,
                 required: REQUIRED,
                 hash_sha256: Some(Sha256::try_from_hex_string(SHA256_STR).unwrap()),