v0.12: Further deprecate base64 byte strings by removing parsing support outside the error path (#566)

* Further deprecate base64 byte strings by removing parsing support outside the error path

* Remove non-test base64 dependency

* Update the CHANGELOG

Author: juntyr

CHANGELOG.md

@@ -6,9 +6,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
-### Additions
+### API Changes
 
+- Breaking: Removed the `ron::error::Error::Base64Error` variant. ([#566](https://github.com/ron-rs/ron/pull/566))
 - Added `into_inner()` method to `ron::ser::Serializer` to retrieve the inner writer. ([#588](https://github.com/ron-rs/ron/pull/588))
+- Removed the `base64` dependency. ([#566](https://github.com/ron-rs/ron/pull/566))
+
+### Format Changes
+
+- **Format-Breaking:** Remote base64-encoded byte strings deserialisation, replaced by Rusty byte strings in v0.9.0 ([#566](https://github.com/ron-rs/ron/pull/566))
 
 ### Bug Fixes
 
@@ -19,9 +25,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### API Changes
 
 - Breaking: `SpannedError` now stores the full error span in span: Span { start: Position, end: Position }`, to facilitate, e.g., language server highlighting of syntax errors.
-
 - Breaking: Added `no_std` support via a new `std` feature (enabled by default). With default features disabled, you must enable the `std` feature to access `de::from_reader`, and the `std::io` operations on `Options`, such as `from_reader`, `from_reader_seed`, `to_io_writer`, and `to_io_writer_pretty` ([#567](https://github.com/ron-rs/ron/pull/567))
-
 - Breaking: Fixed (again) `ron::value::Number` to ensure it is non-exhaustive, to avoid breaking `match`es when feature unification enables more of its variants than expected ([#568](https://github.com/ron-rs/ron/pull/568))
 
 ### Examples

Cargo.toml

@@ -28,28 +28,27 @@ indexmap = ["std", "dep:indexmap"]
 internal-span-substring-test = ["unicode-segmentation"]
 
 [dependencies]
-# FIXME @juntyr remove base64 once old byte strings are fully deprecated
-base64 = { version = "0.22", default-features = false, features = ["alloc"] }
 bitflags = { version = "2.1", default-features = false, features = ["serde"] }
 indexmap = { version = "2.0", default-features = false, features = ["serde"], optional = true }
+once_cell = { version = "1.20", default-features = false, features = ["alloc", "race"] }
 # serde supports i128/u128 from 1.0.60 onwards
 # serde's IntoDeserializer impls suport new constructor from 1.0.139 onwards
 # serde's adjacently tagged enums support integer tags from 1.0.181 onwards
 serde = { version = "1.0.181", default-features = false, features = ["alloc"] }
 serde_derive = { version = "1.0.181", default-features = false }
-unicode-ident = { version = "1.0", default-features = false }
-unicode-segmentation = { version = "1.12.0", optional = true, default-features = false }
 typeid = { version = "1.0.1", default-features = false }
-once_cell = { version = "1.20", default-features = false, features = ["alloc", "race"] }
+unicode-ident = { version = "1.0", default-features = false }
+unicode-segmentation = { version = "1.12.0", default-features = false, optional = true }
 
 [dev-dependencies]
+base64 = { version = "0.22", default-features = false, features = ["std"] }
+bytes = { version = "1.3", default-features = false, features = ["serde"] }
+option_set = { version = "0.3", default-features = false }
 serde = { version = "1.0.181", default-features = false, features = ["std", "derive"] }
 serde_bytes = { version = "0.11", default-features = false, features = ["std"] }
 # serde_json supports the std feature from 1.0.60 onwards
 serde_json = { version = "1.0.60", default-features = false, features = ["std"] }
-option_set = { version = "0.3", default-features = false }
 typetag = { version = "0.2", default-features = false }
-bytes = { version = "1.3", default-features = false, features = ["serde"] }
 
 [package.metadata.docs.rs]
 features = ["integer128", "indexmap"]

src/error.rs

@@ -33,11 +33,6 @@ pub enum Error {
     Fmt,
     Io(String),
     Message(String),
-    #[deprecated(
-        since = "0.9.0",
-        note = "ambiguous base64 byte strings are replaced by strongly typed Rusty b\"byte strings\""
-    )]
-    Base64Error(base64::DecodeError),
     Eof,
     ExpectedArray,
     ExpectedArrayEnd,
@@ -131,8 +126,6 @@ impl fmt::Display for Error {
         match *self {
             Error::Fmt => f.write_str("Formatting RON failed"),
             Error::Io(ref s) | Error::Message(ref s) => f.write_str(s),
-            #[allow(deprecated)]
-            Error::Base64Error(ref e) => write!(f, "Invalid base64: {}", e),
             Error::Eof => f.write_str("Unexpected end of RON"),
             Error::ExpectedArray => f.write_str("Expected opening `[`"),
             Error::ExpectedArrayEnd => f.write_str("Expected closing `]`"),
@@ -530,11 +523,6 @@ mod tests {
         );
         check_error_message(&<Error as SerError>::custom("my-ser-error"), "my-ser-error");
         check_error_message(&<Error as DeError>::custom("my-de-error"), "my-de-error");
-        #[allow(deprecated)]
-        check_error_message(
-            &Error::Base64Error(base64::DecodeError::InvalidPadding),
-            "Invalid base64: Invalid padding",
-        );
         check_error_message(&Error::Eof, "Unexpected end of RON");
         check_error_message(&Error::ExpectedArray, "Expected opening `[`");
         check_error_message(&Error::ExpectedArrayEnd, "Expected closing `]`");

src/parse.rs

@@ -1039,35 +1039,23 @@ impl<'a> Parser<'a> {
             }
         }
 
+        // FIXME @juntyr: remove in v0.13, since only byte_string_no_base64 will
+        //                be used
         if self.consume_char('"') {
             let base64_str = self.escaped_string()?;
             let base64_result = ParsedByteStr::try_from_base64(&base64_str);
 
-            if cfg!(not(test)) {
-                // FIXME @juntyr: remove in v0.12
-                #[allow(deprecated)]
-                base64_result.map_err(Error::Base64Error)
-            } else {
-                match base64_result {
-                    // FIXME @juntyr: enable in v0.12
-                    Ok(byte_str) => Err(expected_byte_string_found_base64(&base64_str, &byte_str)),
-                    Err(_) => Err(Error::ExpectedByteString),
-                }
+            match base64_result {
+                Some(byte_str) => Err(expected_byte_string_found_base64(&base64_str, &byte_str)),
+                None => Err(Error::ExpectedByteString),
             }
         } else if self.consume_char('r') {
             let base64_str = self.raw_string()?;
             let base64_result = ParsedByteStr::try_from_base64(&base64_str);
 
-            if cfg!(not(test)) {
-                // FIXME @juntyr: remove in v0.12
-                #[allow(deprecated)]
-                base64_result.map_err(Error::Base64Error)
-            } else {
-                match base64_result {
-                    // FIXME @juntyr: enable in v0.12
-                    Ok(byte_str) => Err(expected_byte_string_found_base64(&base64_str, &byte_str)),
-                    Err(_) => Err(Error::ExpectedByteString),
-                }
+            match base64_result {
+                Some(byte_str) => Err(expected_byte_string_found_base64(&base64_str, &byte_str)),
+                None => Err(Error::ExpectedByteString),
             }
         } else {
             self.byte_string_no_base64()
@@ -1641,14 +1629,75 @@ impl<'a> ParsedStr<'a> {
 }
 
 impl<'a> ParsedByteStr<'a> {
-    pub fn try_from_base64(str: &ParsedStr<'a>) -> Result<Self, base64::DecodeError> {
+    pub fn try_from_base64(str: &ParsedStr<'a>) -> Option<Self> {
+        // Adapted from MIT licensed Jenin Sutradhar's base 64 decoder
+        // https://github.com/JeninSutradhar/base64-Rust-Encoder-Decoder/blob/ee1fb08cbb78024ec8cf5e786815acb239169f02/src/lib.rs#L84-L128
+        fn try_decode_base64(str: &str) -> Option<Vec<u8>> {
+            const CHARSET: &[u8; 64] =
+                b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+            const PADDING: u8 = b'=';
+
+            // fast reject for missing padding
+            if (str.len() % 4) != 0 {
+                return None;
+            }
+
+            let bstr_no_padding = str.trim_end_matches(char::from(PADDING)).as_bytes();
+
+            // fast reject for excessive padding
+            if (str.len() - bstr_no_padding.len()) > 2 {
+                return None;
+            }
+
+            // fast reject for extraneous bytes after padding
+            if bstr_no_padding.contains(&PADDING) {
+                return None;
+            }
+
+            // fast reject for non-ASCII
+            if !str.is_ascii() {
+                return None;
+            }
+
+            let mut collected_bits = 0_u8;
+            let mut byte_buffer = 0_u16;
+            let mut bytes = bstr_no_padding.iter().copied();
+            let mut binary = Vec::new();
+
+            'decodeloop: loop {
+                while collected_bits < 8 {
+                    if let Some(nextbyte) = bytes.next() {
+                        #[allow(clippy::cast_possible_truncation)]
+                        if let Some(idx) = CHARSET.iter().position(|&x| x == nextbyte) {
+                            byte_buffer |= ((idx & 0b0011_1111) as u16) << (10 - collected_bits);
+                            collected_bits += 6;
+                        } else {
+                            return None;
+                        }
+                    } else {
+                        break 'decodeloop;
+                    }
+                }
+
+                binary.push(((0b1111_1111_0000_0000 & byte_buffer) >> 8) as u8);
+                byte_buffer &= 0b0000_0000_1111_1111;
+                byte_buffer <<= 8;
+                collected_bits -= 8;
+            }
+
+            if usize::from(collected_bits) != ((str.len() - bstr_no_padding.len()) * 2) {
+                return None;
+            }
+
+            Some(binary)
+        }
+
         let base64_str = match str {
             ParsedStr::Allocated(string) => string.as_str(),
             ParsedStr::Slice(str) => str,
         };
 
-        base64::engine::Engine::decode(&base64::engine::general_purpose::STANDARD, base64_str)
-            .map(ParsedByteStr::Allocated)
+        try_decode_base64(base64_str).map(ParsedByteStr::Allocated)
     }
 }
 
@@ -1786,7 +1835,7 @@ mod tests {
     }
 
     #[test]
-    fn v0_10_base64_deprecation_error() {
+    fn base64_deprecation_error() {
         let err = crate::from_str::<bytes::Bytes>("\"SGVsbG8gcm9uIQ==\"").unwrap_err();
 
         assert_eq!(
@@ -1810,7 +1859,10 @@ mod tests {
         assert_eq!(
             crate::from_str::<bytes::Bytes>("\"invalid=\"").unwrap_err(),
             SpannedError {
-                code: Error::ExpectedByteString,
+                code: Error::InvalidValueForType {
+                    expected: String::from("the Rusty byte string b\"\\x8a{\\xda\\x96\\'\""),
+                    found: String::from("the ambiguous base64 string \"invalid=\"")
+                },
                 span: Span {
                     start: Position { line: 1, col: 2 },
                     end: Position { line: 1, col: 11 },
@@ -1821,12 +1873,26 @@ mod tests {
         assert_eq!(
             crate::from_str::<bytes::Bytes>("r\"invalid=\"").unwrap_err(),
             SpannedError {
-                code: Error::ExpectedByteString,
+                code: Error::InvalidValueForType {
+                    expected: String::from("the Rusty byte string b\"\\x8a{\\xda\\x96\\'\""),
+                    found: String::from("the ambiguous base64 string \"invalid=\"")
+                },
                 span: Span {
                     start: Position { line: 1, col: 3 },
                     end: Position { line: 1, col: 12 },
                 }
             }
         );
+
+        assert_eq!(
+            crate::from_str::<bytes::Bytes>("r\"invalid\"").unwrap_err(),
+            SpannedError {
+                code: Error::ExpectedByteString,
+                span: Span {
+                    start: Position { line: 1, col: 3 },
+                    end: Position { line: 1, col: 11 },
+                }
+            }
+        );
     }
 }

tests/438_rusty_byte_strings.rs

@@ -11,86 +11,6 @@ struct BytesStruct {
     large: Vec<u8>,
 }
 
-#[test]
-fn v_9_deprecated_base64_bytes_support() {
-    #![allow(deprecated)]
-
-    // Requires padding of the base64 data
-    assert_eq!(
-        Ok(BytesStruct {
-            small: vec![1, 2],
-            large: vec![1, 2, 3, 4]
-        }),
-        ron::from_str("BytesStruct( small:[1, 2], large:\"AQIDBA==\" )"),
-    );
-
-    // Requires no padding of the base64 data
-    assert_eq!(
-        Ok(BytesStruct {
-            small: vec![1, 2],
-            large: vec![1, 2, 3, 4, 5, 6]
-        }),
-        ron::from_str("BytesStruct( small:[1, 2], large:r\"AQIDBAUG\" )"),
-    );
-
-    // Parsing an escaped byte string is also possible
-    assert_eq!(
-        Ok(BytesStruct {
-            small: vec![1, 2],
-            large: vec![1, 2, 3, 4, 5, 6]
-        }),
-        ron::from_str("BytesStruct( small:[1, 2], large:\"\\x41Q\\x49DBA\\x55G\" )"),
-    );
-
-    // Invalid base64
-    assert_eq!(
-        Err(SpannedError {
-            code: Error::Base64Error(base64::DecodeError::InvalidByte(0, b'_')),
-            span: Span {
-                start: Position { line: 1, col: 35 },
-                end: Position { line: 1, col: 40 }
-            }
-        }),
-        ron::from_str::<BytesStruct>("BytesStruct( small:[1, 2], large:\"_+!!\" )"),
-    );
-
-    // Invalid last base64 symbol
-    assert_eq!(
-        Err(SpannedError {
-            code: Error::Base64Error(base64::DecodeError::InvalidLastSymbol(1, b'x')),
-            span: Span {
-                start: Position { line: 1, col: 35 },
-                end: Position { line: 1, col: 40 }
-            }
-        }),
-        ron::from_str::<BytesStruct>("BytesStruct( small:[1, 2], large:\"/x==\" )"),
-    );
-
-    // Missing padding
-    assert_eq!(
-        Err(SpannedError {
-            code: Error::Base64Error(base64::DecodeError::InvalidPadding),
-            span: Span {
-                start: Position { line: 1, col: 35 },
-                end: Position { line: 1, col: 42 }
-            }
-        }),
-        ron::from_str::<BytesStruct>("BytesStruct( small:[1, 2], large:\"AQIDBA\" )"),
-    );
-
-    // Too much padding
-    assert_eq!(
-        Err(SpannedError {
-            code: Error::Base64Error(base64::DecodeError::InvalidByte(6, b'=')),
-            span: Span {
-                start: Position { line: 1, col: 35 },
-                end: Position { line: 1, col: 45 }
-            }
-        }),
-        ron::from_str::<BytesStruct>("BytesStruct( small:[1, 2], large:\"AQIDBA===\" )"),
-    );
-}
-
 #[test]
 fn rusty_byte_string() {
     assert_eq!(