rsscript: add gzip byte decompression

Author: Haofei

Cargo.lock

@@ -21,6 +21,7 @@ toml = "0.8"
 serde_yaml_ng = "0.10"
 base64 = "0.22"
 chrono = { version = "0.4", default-features = false, features = ["alloc"] }
+flate2 = "1"
 hex = "0.4"
 hmac = "0.12"
 percent-encoding = "2"

crates/rsscript/Cargo.toml

@@ -8,6 +8,7 @@ use std::rc::Rc;
 
 use base64::Engine;
 use chrono::{DateTime, Datelike, NaiveDate, SecondsFormat, TimeZone, Timelike, Utc};
+use flate2::read::GzDecoder;
 use hmac::{Hmac, Mac};
 use percent_encoding::{NON_ALPHANUMERIC, percent_decode_str, utf8_percent_encode};
 use rand::Rng;
@@ -2126,6 +2127,7 @@ enum RegIntrinsic {
     HmacSha256String,
     GlobalConfigNew,
     GlobalConfigRuleCount,
+    GzipDecompressBytes,
     HexDecode,
     HexEncode,
     HexEncodeString,
@@ -4227,6 +4229,7 @@ impl RegLowerer<'_> {
                         return Ok(dst);
                     }
                     ("GlobalConfig", "rule_count") => RegIntrinsic::GlobalConfigRuleCount,
+                    ("Gzip", "decompress_bytes") => RegIntrinsic::GzipDecompressBytes,
                     ("Hex", "decode") => RegIntrinsic::HexDecode,
                     ("Hex", "encode") => RegIntrinsic::HexEncode,
                     ("Hex", "encode_string") => RegIntrinsic::HexEncodeString,
@@ -9758,6 +9761,17 @@ impl RegVm {
                 let global = intrinsic_arg(&self.stack, base, args, 0)?;
                 Ok(VmValue::Int(expect_global_config_rule_count(global)?))
             }
+            RegIntrinsic::GzipDecompressBytes => {
+                let value = expect_bytes_ref(intrinsic_arg(&self.stack, base, args, 0)?)?;
+                let mut decoder = GzDecoder::new(value);
+                let mut out = Vec::new();
+                Ok(json_result(
+                    decoder
+                        .read_to_end(&mut out)
+                        .map(|_| VmValue::Bytes(Rc::new(out)))
+                        .map_err(|error| decode_error_value(error.to_string())),
+                ))
+            }
             RegIntrinsic::HexDecode => {
                 let text = expect_string_ref(intrinsic_arg(&self.stack, base, args, 0)?)?;
                 Ok(json_result(

crates/rsscript/src/reg_vm/mod.rs

@@ -668,6 +668,11 @@ const RUNTIME_INTRINSICS: &[RuntimeIntrinsic] = &[
         "encode_string",
         "rsscript_runtime::hex_encode_string",
     ),
+    runtime_intrinsic(
+        "Gzip",
+        "decompress_bytes",
+        "rsscript_runtime::gzip_decompress_bytes",
+    ),
     runtime_intrinsic("Http", "get", "rsscript_runtime::http_get"),
     runtime_intrinsic("Http", "get_async", "rsscript_runtime::http_get_async"),
     runtime_intrinsic("Http", "send_async", "rsscript_runtime::http_send_async"),

crates/rsscript/src/runtime_abi.rs

@@ -1368,6 +1368,25 @@ fn main() -> Unit {
         Err(error) => Log.write(message: read DecodeError.message(error: read error))
     }
 
+    match Hex.decode(text: read "1f8b08000000000002ff4b4c4a0600c241243503000000") {
+        Ok(gzipped) => {
+            match Gzip.decompress_bytes(value: read gzipped) {
+                Ok(value) => {
+                    Log.write(message: read String.from_int(value: Bytes.len(value: read value)))
+                    Log.write(message: read Hex.encode(value: read value))
+                }
+                Err(error) => Log.write(message: read DecodeError.message(error: read error))
+            }
+        }
+        Err(error) => Log.write(message: read DecodeError.message(error: read error))
+    }
+
+    let bad_gzip = String.to_bytes(value: read "not gzip")
+    match Gzip.decompress_bytes(value: read bad_gzip) {
+        Ok(value) => Log.write(message: read String.from_int(value: Bytes.len(value: read value)))
+        Err(error) => Log.write(message: read DecodeError.message(error: read error))
+    }
+
     let component = Url.encode_component(value: read "a b/é?x=1")
     Log.write(message: read component)
 

crates/rsscript/tests/vm.rs

@@ -1092,6 +1092,25 @@ fn main() -> Unit {
         Err(error) => Log.write(message: read DecodeError.message(error: read error))
     }
 
+    match Hex.decode(text: read "1f8b08000000000002ff4b4c4a0600c241243503000000") {
+        Ok(gzipped) => {
+            match Gzip.decompress_bytes(value: read gzipped) {
+                Ok(value) => {
+                    Log.write(message: read String.from_int(value: Bytes.len(value: read value)))
+                    Log.write(message: read Hex.encode(value: read value))
+                }
+                Err(error) => Log.write(message: read DecodeError.message(error: read error))
+            }
+        }
+        Err(error) => Log.write(message: read DecodeError.message(error: read error))
+    }
+
+    let bad_gzip = String.to_bytes(value: read "not gzip")
+    match Gzip.decompress_bytes(value: read bad_gzip) {
+        Ok(value) => Log.write(message: read String.from_int(value: Bytes.len(value: read value)))
+        Err(error) => Log.write(message: read DecodeError.message(error: read error))
+    }
+
     let component = Url.encode_component(value: read "a b/é?x=1")
     Log.write(message: read component)
 

crates/rsscript/tests/vm_eval_parity.rs

@@ -19,6 +19,7 @@ sha3 = "0.10"
 regex = "1"
 base64 = "0.22"
 chrono = { version = "0.4", default-features = false, features = ["alloc"] }
+flate2 = "1"
 hex = "0.4"
 hmac = "0.12"
 uuid = { version = "1", features = ["v4"] }

crates/runtime/Cargo.toml

@@ -1,6 +1,8 @@
 use base64::Engine;
 use base64::engine::general_purpose::STANDARD;
+use flate2::read::GzDecoder;
 use percent_encoding::{AsciiSet, NON_ALPHANUMERIC, percent_decode_str, utf8_percent_encode};
+use std::io::Read;
 
 #[derive(Debug, Clone)]
 pub struct DecodeError {
@@ -46,6 +48,17 @@ pub fn hex_decode(text: &str) -> Result<Vec<u8>, DecodeError> {
     })
 }
 
+// Gzip
+
+pub fn gzip_decompress_bytes(value: &[u8]) -> Result<Vec<u8>, DecodeError> {
+    let mut decoder = GzDecoder::new(value);
+    let mut out = Vec::new();
+    decoder.read_to_end(&mut out).map_err(|e| DecodeError {
+        message: e.to_string(),
+    })?;
+    Ok(out)
+}
+
 // URL encoding
 
 const COMPONENT_SET: &AsciiSet = &NON_ALPHANUMERIC
@@ -70,3 +83,21 @@ pub fn url_decode_component(value: &str) -> Result<String, DecodeError> {
 pub fn decode_error_message(error: &DecodeError) -> String {
     error.message.clone()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn gzip_decompress_bytes_decodes_gzip_payload() {
+        let gzipped = hex::decode("1f8b08000000000002ff4b4c4a0600c241243503000000").unwrap();
+        let decoded = gzip_decompress_bytes(&gzipped).unwrap();
+        assert_eq!(decoded, b"abc");
+    }
+
+    #[test]
+    fn gzip_decompress_bytes_reports_decode_errors() {
+        let err = gzip_decompress_bytes(b"not gzip").unwrap_err();
+        assert!(!err.message.is_empty());
+    }
+}

crates/runtime/src/encoding.rs

@@ -23,6 +23,9 @@ pub native fn Hex.encode_string(value: read String) -> fresh String
 pub native fn Hex.decode(text: read String) -> Result<fresh Bytes, DecodeError>
     effects(native)
 
+pub native fn Gzip.decompress_bytes(value: read Bytes) -> Result<fresh Bytes, DecodeError>
+    effects(native)
+
 pub native fn Url.encode_component(value: read String) -> fresh String
     effects(native)