--- /dev/null
+[root]
+name = "lab1_rust"
+version = "0.0.1"
+dependencies = [
+ "openssl 0.0.0 (git+https://github.com/sfackler/rust-openssl.git#b41201c3c9fddf42d02f71d11b5d4718eb9e88c4)",
+]
+
+[[package]]
+name = "openssl"
+version = "0.0.0"
+source = "git+https://github.com/sfackler/rust-openssl.git#b41201c3c9fddf42d02f71d11b5d4718eb9e88c4"
+
--- /dev/null
+[package]
+
+name = "lab1_rust"
+version = "0.0.1"
+authors = ["Ummon <greg.burri@gmail.com>"]
+
+
+[[bin]]
+
+name = "lab1_rust"
+
+
+[dependencies.openssl]
+
+git = "https://github.com/sfackler/rust-openssl.git"
\ No newline at end of file
--- /dev/null
+use std::io::{ TcpStream, IoResult };
+use command::{ Command, Packet, Error };
+use crypto::Crypto;
+
+pub struct Client {
+ socket: TcpStream,
+ crypto: Crypto,
+ current_timestamp: u64
+}
+
+impl Client {
+ pub fn new(address: &str, port: u16) -> IoResult<Client> {
+ Ok(Client {
+ socket: try!(TcpStream::connect(address, port)),
+ current_timestamp: 0,
+ crypto: Crypto::new()
+ })
+ }
+
+ pub fn close(&mut self) {
+ self.socket.close_read();
+ self.socket.close_write();
+ }
+
+ pub fn start_tests(&mut self) {
+
+ let command = Packet::newRandomCommand(self.current_timestamp);
+ self.send(command);
+
+ }
+
+ fn send(&mut self, p: Packet) {
+ p.write(&mut self.socket);
+ }
+}
\ No newline at end of file
--- /dev/null
+use std::io;
+use std::rand::{ random, task_rng, distributions };
+use std::rand::distributions::IndependentSample;
+
+pub enum ReadingError {
+ ReadIOError(io::IoError)
+ // TODO...
+}
+
+pub enum WritingError {
+ WriteIOError(io::IoError)
+ // TODO...
+}
+
+pub type ReadingResult = Result<Packet, ReadingError>;
+pub type WritingResult = Result<(), WritingError>;
+
+pub enum PacketType {
+ CommandType,
+ AnswerType
+}
+
+pub struct CommandPacket {
+ t: PacketType,
+ timestamp: u64,
+ commandID: u8,
+ commandPayload: Vec<u8>
+}
+
+pub struct ErrorPacket {
+ timestamp: u64
+}
+
+pub enum Packet {
+ Command(CommandPacket),
+ Error(ErrorPacket)
+}
+
+impl Packet {
+ pub fn newRandomCommand(timestamp: u64) -> Packet {
+
+ let mut rng = task_rng();
+ Command(CommandPacket {
+ t: CommandType,
+ timestamp: timestamp,
+ commandID: random::<u8>(),
+ commandPayload: Vec::from_fn(distributions::Range::new(7u, 40u).ind_sample(&mut rng), |idx| 0u8)
+ })
+ }
+
+ pub fn write(&self, output: &mut io::Writer) -> WritingResult {
+
+ match self {
+ &Command(ref command) => {
+ output.write_u8(0);
+ output.write_be_u64(command.timestamp);
+
+
+ },
+ &Error(error) => ()
+ }
+
+ Ok(())
+ }
+
+ pub fn read(input: &mut io::Reader) -> ReadingResult {
+ Ok(Packet::newRandomCommand(0))
+ }
+}
\ No newline at end of file
--- /dev/null
+use std::rand::OsRng;
+use std::vec::Vec;
+use std::io::IoResult;
+use std::rand::Rng;
+
+use openssl::crypto::hash::SHA256;
+use openssl::crypto::hmac::HMAC;
+use std::slice::bytes::copy_memory;
+
+//const KEY_A: &'static [u8] = "49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d".from_hex().unwrap();
+//static KEY_A: Vec<u8> = vec![1, 2, 3]; // "49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d".from_hex().unwrap();
+
+pub struct Crypto {
+ key_a: Vec<u8>,
+ key_c: Vec<u8>
+}
+
+impl Crypto {
+ pub fn new() -> Crypto {
+ Crypto {
+ key_a: [125, 31, 131, 118, 143, 180, 252, 53, 211, 217, 79, 240, 128, 91, 252, 87, 104, 236, 145, 198, 163, 203, 161, 12, 53, 56, 218, 40, 221, 95, 171, 140].to_vec(),
+ key_c: [75, 226, 88, 31, 223, 216, 182, 216, 178, 58, 59, 193, 245, 80, 254, 128, 125, 246, 246, 224, 194, 190, 123, 123, 10, 131, 217, 183, 112, 157, 166, 102].to_vec()
+ }
+ }
+
+ pub fn compute_mac(&self, data: &[u8]) -> [u8, ..10] {
+ let mut hmac = HMAC(SHA256, self.key_a.as_slice());
+ hmac.update(data);
+ let mut result = [0u8, ..10];
+ copy_memory(&mut result, hmac.finalize().slice(0, 9));
+ result
+ }
+}
+
+pub fn encrypt(plaindata: &Vec<u8>) -> Vec<u8> {
+ vec!()
+}
+
+pub fn decrypt(cypherdata: &Vec<u8>) -> Vec<u8> {
+ vec!()
+}
+
+pub fn generate_key(size_byte: uint) -> IoResult<Vec<u8>> {
+ let mut bytes = Vec::from_elem(size_byte, 0u8);
+ let mut generator = try!(OsRng::new());
+ generator.fill_bytes(bytes.as_mut_slice_());
+ Ok(bytes)
+}
\ No newline at end of file
--- /dev/null
+extern crate openssl;
+
+use std::io;
+use std::os;
+
+mod crypto;
+mod command;
+mod client;
+mod server;
+
+/*
+TODO
+ * Comment stocker les clefs? à quels critères doivent elle répondre?
+ *
+*/
+
+const PORT: u16 = 4221;
+
+fn print_usage() {
+ println!("{} <genkey> | ...", os::args()[0]);
+}
+
+fn main() {
+ let args = os::args();
+
+ if args.iter().any(|a| a.as_slice() == "--help" || a.as_slice() == "-h") {
+ print_usage();
+ } else if args.len() > 1 && args[1].as_slice() == "genkey" {
+ match crypto::generate_key(256 / 8) {
+ Ok(key) => println!("key: {}", key),
+ Err(e) => println!("Unable to generate a key. Error: {}", e)
+ }
+ } else {
+ match server::Server::new(PORT) {
+ Ok(mut server) => {
+ println!("Server started");
+
+ match client::Client::new("127.0.0.1", PORT) {
+ Ok(mut client) => {
+ client.start_tests();
+ client.close();
+ },
+ Err(e) => {
+ println!("Unable to create a client. Error: {}", e);
+ return
+ }
+ }
+
+ println!("Press any key to quit");
+ io::stdin().read_line().ok().expect("Failed to read line");
+ server.close().ok().expect("Failed to close the server");
+ },
+ Err(e) => println!("Unable to create a new server. Error: {}", e)
+ }
+ }
+}
--- /dev/null
+use std::io::{ TcpListener, TcpStream, Acceptor, Listener, IoError, IoResult };
+use std::io::net::tcp::{ TcpAcceptor };
+use command::{ Command, Packet, Error };
+use crypto::Crypto;
+
+pub struct Server {
+ acceptor: TcpAcceptor,
+ crypto: Crypto
+}
+
+impl Server {
+ pub fn new(port: u16) -> IoResult<Server> {
+ let mut acceptor = try!(TcpListener::bind("127.0.0.1", port).listen());
+ let server = Server {
+ acceptor: acceptor.clone(),
+ crypto: Crypto::new()
+ };
+
+ spawn(proc() {
+ loop {
+ for stream in acceptor.incoming() {
+ match stream {
+ Err(_) => return,
+ Ok(stream) => spawn(proc() {
+ Server::handle_client(stream);
+ })
+ }
+ }
+ }
+ });
+
+ Ok(server)
+ }
+
+ pub fn close(&mut self) -> IoResult<()> {
+ self.acceptor.close_accept()
+ }
+
+ fn handle_client(mut stream: TcpStream) {
+ println!("new connection!");
+ let mut current_timestamp = 0u64;
+ match Packet::read(&mut stream) {
+ Ok(Command(packet)) => println!("CommandPacket"),
+ Ok(Error(packet)) => println!("AnswerPacket"),
+ Err(io_error) => println!("IO Error")
+ }
+ }
+}
\ No newline at end of file
projects / crypto_lab1.git / commitdiff