upload working

Cargo.toml

@@ -5,4 +5,9 @@ members = [
     "dnstp",
     "dnstp-client",
     "dnstp-server",
-]
+]
+
+[workspace.package]
+version = "0.1.1"
+authors = ["sarsoo <[email protected]>"]
+documentation = "https://sarsoo.github.io/dnstp"

dnstp-client/Cargo.toml

@@ -1,6 +1,8 @@
 [package]
 name = "dnstp-client"
-version = "0.1.0"
+version.workspace = true
+authors.workspace = true
+documentation.workspace = true
 edition = "2021"
 publish = false
 
@@ -11,4 +13,5 @@ dnstplib = { path = "../dnstp" }
 clap = { version = "4.5.11", features = ["derive"] }
 log = "0.4.22"
 simplelog = "0.12.2"
-rand = "0.8.5"
+rand = "0.8.5"
+base64 = "0.22.1"

dnstp-client/src/download.rs

@@ -1,6 +1,6 @@
 use crate::NetSettings;
 
-pub fn download(net_settings: NetSettings)
+pub fn download(_net_settings: NetSettings)
 {
 
 }

dnstp-client/src/main.rs

@@ -15,6 +15,7 @@ use crate::test::send_test_requests;
 use crate::upload::upload;
 
 #[derive(Parser, Debug)]
+#[command(name = "DNSTP")]
 #[command(author, version, about, long_about = None)]
 struct Args {
     #[clap(subcommand)]
@@ -33,7 +34,7 @@ enum Command {
         #[clap(flatten)]
         net_options: NetSettings,
         #[arg(short, long)]
-        value: String
+        value: Vec<String>
     },
     /// Download a payload from the remote server
     Download {

dnstp-client/src/test.rs

@@ -4,7 +4,7 @@ use std::thread;
 use std::time::Duration;
 use log::info;
 use rand::RngCore;
-use dnstplib::client_crypto_context::ClientCryptoContext;
+use dnstplib::session::client_crypto_context::ClientCryptoContext;
 use dnstplib::DomainConfig;
 use dnstplib::message::DNSMessage;
 use dnstplib::net::{DNSSocket, NetworkMessage};
@@ -42,10 +42,12 @@ pub fn send_test_requests(args: NetSettings)
 
         let bytes = message.to_bytes();
 
-        tx_channel.send(Box::new(NetworkMessage {
+        if let Err(_) = tx_channel.send(Box::new(NetworkMessage {
             buffer: Box::new(bytes),
             peer: args.address.parse().unwrap()
-        }));
+        })) {
+
+        }
 
         thread::sleep(Duration::from_secs(1));
     }

dnstp-client/src/upload.rs

@@ -3,16 +3,14 @@ use std::sync::{Arc, Mutex};
 use std::thread;
 use std::time::Duration;
 use log::info;
-use rand::RngCore;
 use rand::rngs::OsRng;
-use dnstplib::client_crypto_context::ClientCryptoContext;
+use dnstplib::session::{ClientCryptoContext, generate_client_handshake_message, generate_string_encryption_message};
 use dnstplib::{DomainConfig, send_message};
-use dnstplib::message::{Direction, DNSHeader, DNSMessage, DNSQuestion, Opcode, QClass, QType, ResponseCode};
 use dnstplib::net::DNSSocket;
 use dnstplib::processor::ResponseProcesor;
 use crate::NetSettings;
 
-pub fn upload(net_settings: NetSettings, value: String)
+pub fn upload(net_settings: NetSettings, values: Vec<String>)
 {
     let address = SocketAddr::from(([127, 0, 0, 1], 0));
 
@@ -35,39 +33,7 @@ pub fn upload(net_settings: NetSettings, value: String)
 
     info!("sending handshake...");
 
-    let message = DNSMessage {
-        header: DNSHeader {
-            id: OsRng.next_u32() as u16,
-            direction: Direction::Request,
-            opcode: Opcode::Query,
-            authoritative: false,
-            truncation: false,
-            recursion_desired: false,
-            recursion_available: false,
-            valid_zeroes: true,
-            response: ResponseCode::NoError,
-            question_count: 2,
-            answer_record_count: 0,
-            authority_record_count: 0,
-            additional_record_count: 0,
-        },
-        questions: vec![
-            DNSQuestion {
-                qname: domain_config.get_fq_key_endpoint(),
-                qtype: QType::A,
-                qclass: QClass::Internet,
-            },
-            DNSQuestion {
-                qname: crypto_context.lock().unwrap().get_public_key_domain(&domain_config.base_domain),
-                qtype: QType::A,
-                qclass: QClass::Internet,
-            }
-        ],
-        answer_records: vec![],
-        authority_records: vec![],
-        additional_records: vec![],
-        peer: net_settings.address.parse().unwrap(),
-    };
+    let message = generate_client_handshake_message(&mut OsRng, &domain_config, crypto_context.clone(), &net_settings.address);
 
     send_message(message, &tx_channel);
 
@@ -78,4 +44,19 @@ pub fn upload(net_settings: NetSettings, value: String)
     }
 
     info!("crypto complete, sending data");
+
+    for v in values {
+
+        info!("sending [{}]", v);
+
+        if let Ok(encryption_message) = generate_string_encryption_message(
+            v,
+            &mut OsRng,
+            &domain_config,
+            crypto_context.clone(),
+            &net_settings.address
+        ) {
+            send_message(encryption_message, &tx_channel);
+        }
+    }
 }

dnstp-server/Cargo.toml

@@ -1,6 +1,8 @@
 [package]
 name = "dnstp"
-version = "0.1.0"
+version.workspace = true
+authors.workspace = true
+documentation.workspace = true
 edition = "2021"
 publish = false
 

dnstp-server/src/main.rs

@@ -17,6 +17,7 @@ use dnstplib::processor::RequestProcesor;
 
 /// Command-line arguments for configuring the server
 #[derive(Parser, Debug)]
+#[command(name = "DNSTPd")]
 #[command(author, version, about, long_about = None)]
 struct Args {
     /// Addresses to bind server to

dnstp/Cargo.toml

@@ -1,6 +1,8 @@
 [package]
 name = "dnstplib"
-version = "0.1.0"
+version.workspace = true
+authors.workspace = true
+documentation.workspace = true
 edition = "2021"
 publish = ["sargit"]
 
@@ -12,4 +14,5 @@ urlencoding = "2.1.3"
 
 rand_core = { version = "0.6.4", features = ["getrandom"] }
 p256 = { version = "0.13.2", features = ["ecdh"] }
-aes-gcm-siv = "0.11.1"
+aes-gcm-siv = "0.11.1"
+base64 = "0.22.1"

dnstp/src/crypto/mod.rs

@@ -49,14 +49,6 @@ pub fn get_shared_asym_secret(secret: &EphemeralSecret, opposing_public_key: &St
     }
 }
 
-// pub fn generate_aes_nonce() -> Nonce
-// {
-//     let mut nonce_buffer: [u8; 12] = [0; 12];
-//     &OsRng.fill_bytes(&mut nonce_buffer);
-//
-//     Nonce::from(nonce_buffer)
-// }
-
 /// Generate a safe nonce to use in symmetric encryption
 pub fn generate_aes_nonce() -> Nonce
 {

dnstp/src/lib.rs

@@ -1,19 +1,16 @@
 //! # Common Functionality
 //! The vast majority of functionality is in this library crate. The client and server executable crates are really just wiring up bits and pieces from this library.
 
-pub mod message_parser;
-
 mod byte;
 pub mod processor;
 pub mod message;
 pub mod net;
 pub mod string;
 pub mod config;
 pub mod crypto;
-pub mod clients;
-pub mod client_crypto_context;
+pub mod session;
 
-use std::sync::mpsc::{Sender};
+use std::sync::mpsc::Sender;
 use log::error;
 pub use config::DomainConfig;
 use crate::message::DNSMessage;

dnstp/src/message/header.rs

@@ -102,29 +102,29 @@ impl DNSHeader {
     {
         let mut header_bytes: [u8; 12] = [0; 12];
 
-        apply_split_bytes(&mut header_bytes, self.id, crate::message_parser::ID_START);
+        apply_split_bytes(&mut header_bytes, self.id, crate::message::message_parser::ID_START);
 
         let mut flags: u16 = 0;
 
         if self.direction == Response {
-            flags |= 0b1 << crate::message_parser::DIRECTION_SHIFT;
+            flags |= 0b1 << crate::message::message_parser::DIRECTION_SHIFT;
         }
 
-        flags |= (self.opcode as u16) << crate::message_parser::OPCODE_SHIFT;
+        flags |= (self.opcode as u16) << crate::message::message_parser::OPCODE_SHIFT;
 
-        flags |= (self.authoritative as u16) << crate::message_parser::AUTHORITATIVE_SHIFT;
-        flags |= (self.truncation as u16) << crate::message_parser::TRUNCATION_SHIFT;
-        flags |= (self.recursion_desired as u16) << crate::message_parser::RECURSION_DESIRED_SHIFT;
-        flags |= (self.recursion_available as u16) << crate::message_parser::RECURSION_AVAILABLE_SHIFT;
+        flags |= (self.authoritative as u16) << crate::message::message_parser::AUTHORITATIVE_SHIFT;
+        flags |= (self.truncation as u16) << crate::message::message_parser::TRUNCATION_SHIFT;
+        flags |= (self.recursion_desired as u16) << crate::message::message_parser::RECURSION_DESIRED_SHIFT;
+        flags |= (self.recursion_available as u16) << crate::message::message_parser::RECURSION_AVAILABLE_SHIFT;
 
         flags |= self.response as u16;
 
-        apply_split_bytes(&mut header_bytes, flags, crate::message_parser::FLAGS_START);
+        apply_split_bytes(&mut header_bytes, flags, crate::message::message_parser::FLAGS_START);
 
-        apply_split_bytes(&mut header_bytes, self.question_count, crate::message_parser::QUESTION_COUNT_START);
-        apply_split_bytes(&mut header_bytes, self.answer_record_count, crate::message_parser::ANSWER_RECORD_COUNT_START);
-        apply_split_bytes(&mut header_bytes, self.authority_record_count, crate::message_parser::AUTHORITY_RECORD_COUNT_START);
-        apply_split_bytes(&mut header_bytes, self.additional_record_count, crate::message_parser::ADDITIONAL_RECORD_COUNT_START);
+        apply_split_bytes(&mut header_bytes, self.question_count, crate::message::message_parser::QUESTION_COUNT_START);
+        apply_split_bytes(&mut header_bytes, self.answer_record_count, crate::message::message_parser::ANSWER_RECORD_COUNT_START);
+        apply_split_bytes(&mut header_bytes, self.authority_record_count, crate::message::message_parser::AUTHORITY_RECORD_COUNT_START);
+        apply_split_bytes(&mut header_bytes, self.additional_record_count, crate::message::message_parser::ADDITIONAL_RECORD_COUNT_START);
 
         header_bytes
     }

dnstp/src/message/message.rs

@@ -153,7 +153,7 @@ impl DNSMessage {
         response
     }
 
-    pub fn protocol_error_from_request(&self, error_code: RequestError) -> DNSMessage
+    pub fn protocol_error_from_request(&self, _error_code: RequestError) -> DNSMessage
     {
         let txt = Box::new(TXTRdata::from(String::new()));
 

dnstp/src/message_parser.rs → dnstp/src/message/message_parser.rs

@@ -3,7 +3,7 @@
 use crate::byte;
 use crate::message::{DNSMessage, Direction, DNSHeader, Opcode, ResponseCode, QuestionParseError, questions_from_bytes, records_from_bytes, RecordParseError};
 use crate::net::NetworkMessage;
-use crate::message_parser::MessageParseError::{HeaderParse, QuesionsParse};
+use crate::message::MessageParseError::{HeaderParse, QuesionsParse};
 
 pub const ID_START: usize = 0;
 pub const FLAGS_START: usize = 2;

dnstp/src/message/mod.rs

@@ -3,8 +3,10 @@ pub mod header;
 pub mod question;
 pub mod message;
 pub mod record;
+pub mod message_parser;
 
-pub use question::{DNSQuestion, QClass, QType, QuestionParseError, questions_to_bytes, questions_from_bytes};
-pub use record::{ResourceRecord, RawRData, RData, ARdata, AAAARdata, TXTRdata, RecordParseError, records_to_bytes, records_from_bytes};
-pub use header::{DNSHeader, Direction, Opcode, ResponseCode, HEADER_SIZE};
-pub use message::DNSMessage;
+pub use question::{DNSQuestion, QClass, QType, QuestionParseError, questions_from_bytes, questions_to_bytes};
+pub use record::{AAAARdata, ARdata, RawRData, RData, RecordParseError, records_from_bytes, records_to_bytes, ResourceRecord, TXTRdata};
+pub use header::{Direction, DNSHeader, HEADER_SIZE, Opcode, ResponseCode};
+pub use message::DNSMessage;
+pub use message_parser::*;

dnstp/src/message/question/tests.rs

@@ -19,7 +19,7 @@ fn one_question_back_and_forth() {
     let mut q_bytes = q.to_bytes();
     q_bytes.append(&mut vec![0, 0, 0, 0, 0, 0]);
 
-    let (q_reconstructed, q_remaining) = questions_from_bytes(q_bytes, 1).unwrap();
+    let (q_reconstructed, _q_remaining) = questions_from_bytes(q_bytes, 1).unwrap();
 
     assert_questions_eq!(q, q_reconstructed[0]);
 }
@@ -43,7 +43,7 @@ fn two_questions_back_and_forth() {
 
     q_bytes.append(&mut q2_bytes);
 
-    let (q_reconstructed, q_remaining) = questions_from_bytes(q_bytes, 2).unwrap();
+    let (q_reconstructed, _q_remaining) = questions_from_bytes(q_bytes, 2).unwrap();
 
     assert_questions_eq!(q, q_reconstructed[0]);
     assert_questions_eq!(q2, q_reconstructed[1]);
@@ -76,7 +76,7 @@ fn three_questions_back_and_forth() {
     q_bytes.append(&mut q2_bytes);
     q_bytes.append(&mut q3_bytes);
 
-    let (q_reconstructed, q_remaining) = questions_from_bytes(q_bytes, 3).unwrap();
+    let (q_reconstructed, _q_remaining) = questions_from_bytes(q_bytes, 3).unwrap();
 
     assert_questions_eq!(q, q_reconstructed[0]);
     assert_questions_eq!(q2, q_reconstructed[1]);