fixing lengths

src/server.rs

@@ -204,8 +204,7 @@ impl<'a> DnsTunnel {
                 let data = data[0];
 
                 // Decode/Decrypt the data
-                let data = b64decode(data);
-                let data = String::from_utf8_lossy(&xor(&data, 0xF5)).to_string();
+                let data = decode(data.to_string(), 0xF5);
 
 
                 // Return DNS Packet
@@ -234,9 +233,9 @@ impl<'a> DnsTunnel {
                             PollStatus::STARTED => {
 
                                 let mut chunk = String::new();
-                                if self.server_buffer.len() >= 63 {
-                                    chunk = self.server_buffer[..63].to_string();
-                                    self.server_buffer = self.server_buffer[63..].to_string();
+                                if self.server_buffer.len() >= 150 {
+                                    chunk = self.server_buffer[..150].to_string();
+                                    self.server_buffer = self.server_buffer[150..].to_string();
                                 } else {
                                     chunk.push_str(&self.server_buffer);
                                     self.server_buffer = String::new();
@@ -273,8 +272,7 @@ impl<'a> DnsTunnel {
     fn send_recv(&self, message: &str) -> Result<String, ()> {
 
         // Take care of the encoding
-        let bytes = xor(message.as_bytes(), 0xF5);
-        let message = &b64encode(bytes);
+        let message = encode(message.to_string(), 0xF5);
 
         // Craft new request with `INIT`
         let mut pkt = self.get_txt_request(&self.domain, message.to_string());
@@ -308,8 +306,7 @@ impl<'a> DnsTunnel {
 
 
         // Take care of the encoding
-        let bytes = xor(message.as_bytes(), 0xF5);
-        let message = &b64encode(bytes);
+        let message = encode(message.to_string(), 0xF5);
 
         // Craft new request with `INIT`
         let mut pkt = self.get_txt_request(&self.domain, message.to_string());
@@ -327,6 +324,7 @@ impl<'a> DnsTunnel {
                 ref txt,
                 ttl
             } => {
+                let txt = decode(txt.to_string(), 0xF5);
                 if txt == "ACK" {
                     return true;
                 }
@@ -358,20 +356,21 @@ impl<'a> DnsTunnel {
 
         loop {
             if let Ok(data) = self.send_recv("POLL") {
+                let raw_data = data.clone();
+                let data = decode(data, 0xF5);
                 match &data[..] {
                     "START" => {
-                        println!("Start");
                         wait_for_data = true;
                     },
                     "END" => {
                         wait_for_data = false;
-                        return Some(return_data);
+                        return Some(decode(return_data, 0xF5));
                     },
                     "NONE" => {
                         return None;
                     },
                     _ => {
-                        return_data.push_str(&data);
+                        return_data.push_str(&raw_data);
                     }
 
                 }
@@ -388,7 +387,7 @@ impl<'a> DnsTunnel {
         packet.header.query_response = true;
         packet.header.result_code = ResultCode::NOERROR;
         let domain = &ref_pkt.questions[0].name;
-
+        let data = encode(data, 0xF5);
         let answer = DnsRecord::TXT {
             domain: domain.to_string(),
             len: data.len() as u8,

src/utilities.rs

@@ -1,15 +1,15 @@
 use base64;
 
 // bas
-pub fn b64encode(data: Vec<u8>) -> String {
+fn b64encode(data: Vec<u8>) -> String {
     base64::encode_config(&data, base64::URL_SAFE)
 }
 
-pub fn b64decode(data: &str) -> Vec<u8> {
+fn b64decode(data: &str) -> Vec<u8> {
     base64::decode_config(&data, base64::URL_SAFE).unwrap()
 }
 
-pub fn xor(data: &[u8], key: u8) -> Vec<u8> {
+fn xor(data: &[u8], key: u8) -> Vec<u8> {
     let mut encoded: Vec<u8> = Vec::new();
     for byte in data {
         encoded.push((key ^ byte) & 0xFF);
@@ -17,4 +17,16 @@ pub fn xor(data: &[u8], key: u8) -> Vec<u8> {
     return encoded;
 }
 
+pub fn encode(data: String, key: u8) -> String {
+    let xor_bytes = xor(data.as_bytes(), key);
+    return b64encode(xor_bytes);
+
+}
+
+pub fn decode(data: String, key: u8) -> String {
+
+    let data = b64decode(&data[..]);
+    return String::from_utf8_lossy(&xor(&data, 0xF5)).to_string();
+}
+