add tests

revert if let merge

.github/workflows/rust.yml

@@ -11,6 +11,10 @@ jobs:
 
     steps:
       - uses: actions/checkout@v3
+
+      - name: Tests
+        run: cargo test --verbose
+
       - name: Build
         run: cargo build --verbose --release
 

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "dns-rebinder"
 authors = ["sinderella"]
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -16,3 +16,7 @@ nonzero_ext = "0.3.0"
 rand = "0.8.5"
 tokio = { version = "1", features = ["full"] }
 trust-dns-proto = "0.21.2"
+
+[dev-dependencies]
+assert_cmd = "2.0"
+predicates = "2.1"

src/ip.rs

@@ -0,0 +1,61 @@
+use std::net::Ipv4Addr;
+
+#[derive(Clone, Copy)]
+pub(crate) struct IP {}
+
+impl IP {
+    pub(crate) fn encode(primary: &Ipv4Addr, secondary: &Ipv4Addr, domain: &str) -> String {
+        let encoded_primary = hex::encode(&primary.octets());
+        let encoded_secondary = hex::encode(&secondary.octets());
+
+        format!("{}.{}.{}", encoded_primary, encoded_secondary, domain)
+    }
+
+    pub(crate) fn decode(
+        encoded_domain: &str,
+    ) -> Result<(Ipv4Addr, Ipv4Addr), Box<dyn std::error::Error>> {
+        if encoded_domain.matches('.').count() < 2 {
+            panic!("incorrect format, multi-level subdomain is required");
+        }
+        let parts: Vec<&str> = encoded_domain.split('.').collect();
+
+        let primary = Ipv4Addr::from(u32::from_str_radix(parts[0], 16).unwrap());
+        let secondary = Ipv4Addr::from(u32::from_str_radix(parts[1], 16).unwrap());
+
+        Ok((primary, secondary))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::ip::IP;
+    use std::net::Ipv4Addr;
+
+    #[test]
+    fn test_ipencoding() -> Result<(), Box<dyn std::error::Error>> {
+        let primary = Ipv4Addr::new(127, 0, 0, 1);
+        let secondary = Ipv4Addr::new(192, 168, 1, 1);
+        let domain = "rebnd.icu";
+
+        assert_eq!(
+            IP::encode(&primary, &secondary, domain),
+            "7f000001.c0a80101.rebnd.icu"
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_ipdecoding() -> Result<(), Box<dyn std::error::Error>> {
+        let encoded_domain = "7f000001.c0a80101.rebnd.icu";
+
+        let primary = Ipv4Addr::new(127, 0, 0, 1);
+        let secondary = Ipv4Addr::new(192, 168, 1, 1);
+
+        let (primary_decoded, secondary_decoded) = IP::decode(encoded_domain).unwrap();
+        assert_eq!(primary, primary_decoded);
+        assert_eq!(secondary, secondary_decoded);
+
+        Ok(())
+    }
+}

src/main.rs

@@ -10,6 +10,7 @@
 
 use crate::cli::Cli;
 use crate::cli::Commands;
+use crate::ip::IP;
 
 use clap::Parser;
 use env_logger::Builder;
@@ -31,6 +32,7 @@ use trust_dns_proto::rr::rdata::SOA;
 use trust_dns_proto::rr::{Name, RData, Record, RecordType};
 
 mod cli;
+mod ip;
 
 type Error = Box<dyn std::error::Error>;
 type Result<T> = std::result::Result<T, Error>;
@@ -79,26 +81,14 @@ fn process_query(
                 return Ok(records);
             }
 
-            let loopback = u32::from_be_bytes(Ipv4Addr::new(127, 0, 0, 1).octets());
-
-            let primary = match u32::from_str_radix(parts[0], 16) {
-                Ok(decoded) => decoded,
-                Err(_) => return Ok(records),
-            };
-            let secondary = match u32::from_str_radix(parts[1], 16) {
-                Ok(decoded) => decoded,
-                Err(_) => return Ok(records),
-            };
+            let (primary, secondary) = IP::decode(&qname).unwrap();
 
             info!(
                 "{:?}[{:?}] - parsed targets: primary: {:#?}, secondary: {:#?}",
-                addr,
-                header_id,
-                Ipv4Addr::from(primary),
-                Ipv4Addr::from(secondary)
+                addr, header_id, primary, secondary
             );
 
-            if primary.eq(&secondary) && primary.ne(&loopback) {
+            if primary.eq(&secondary) {
                 warn!(
                     "{:?}[{:?}] - primary and secondary labels are indentical, possibly an abuse",
                     addr, header_id
@@ -113,8 +103,8 @@ fn process_query(
                 query.name().clone(),
                 1,
                 RData::A(match is_primary {
-                    true => Ipv4Addr::from(primary),
-                    false => Ipv4Addr::from(secondary),
+                    true => primary,
+                    false => secondary,
                 }),
             ));
 
@@ -226,13 +216,10 @@ async fn main() -> Result<()> {
             "Domain: {}, Primary: {:?}, Secondary: {:?}",
             domain, primary, secondary
         );
-        let encoded_primary = hex::encode(&primary.octets());
-        let encoded_secondary = hex::encode(&secondary.octets());
 
-        println!(
-            "Encoded: {}.{}.{}",
-            encoded_primary, encoded_secondary, domain
-        );
+        let encoded_domain = ip::IP::encode(primary, secondary, &domain);
+
+        println!("Encoded: {}", encoded_domain);
         return Ok(());
     }