lab1_rust/src/main.rs

   1 #![feature(macro_rules)]
   2
   3 extern crate openssl;
   4 extern crate serialize;
   5
   6 use std::io;
   7 use std::os;
   8
   9 use end_point::{ Client, Server };
  10
  11 mod utils;
  12 mod crypto;
  13 mod packet;
  14 mod end_point;
  15 mod oracle_machine;
  16
  17 const PORT: u16 = 4221;
  18
  19 fn do_oracle_attack(address: &str, variant: packet::Variant) {
  20    // 16 bytes encrypted data from 'Packet::random_packet_data([4])'.
  21    let cipher_block = [191, 192, 149, 84, 202, 163, 109, 230, 173, 249, 170, 248, 83, 60, 228, 111]; // Known by the attacker.
  22    let xor_operand = [213, 29, 217, 187, 93, 103, 76, 129, 233, 142, 98, 83, 69, 50, 97, 91]; // This is the IV or the previous 16 bytes cipherblock. In our case we took the previous block.
  23    let expected_plain_block = [242, 93, 12, 22, 8, 164, 4, 77, 200, 120, 189, 71, 75, 189, 2, 2]; // To be found by the attacker.
  24
  25    /* Another sample with an IV instead of a previous block.
  26    let cipher_block: [u8, ..16] = [254, 9, 228, 149, 60, 42, 165, 34, 233, 75, 112, 57, 37, 9, 116, 103];
  27    let xor_operand: [u8, ..16] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3]; IV.
  28    let expected_plain_block: [u8, ..16] = [44, 92, 31, 98, 220, 84, 226, 53, 58, 94, 45, 25, 242, 6, 199, 1];
  29    */
  30
  31    match oracle_machine::decipher(address, PORT, &xor_operand, &cipher_block, variant) {
  32       Some(ref deciphered) if deciphered.as_slice() == expected_plain_block => {
  33          println!("The oracle machine has found the plain block!:");
  34          println!("   Expected block: {}", expected_plain_block.to_vec());
  35          println!("   Decrypted block: {}", deciphered)
  36       }
  37       Some(ref other) =>
  38          println!("The oracle machine hasn't found the plain block: {}", other),
  39       _ =>
  40          println!("The oracle machine hasn't found the plain block"),
  41    }
  42 }
  43
  44 fn print_usage() {
  45    println!(
  46       r"{} [genkey | tests | oracle-weak | oracle-fixed]
  47    genkey: Generate a 256 bits key
  48    tests: launch some tests between a client and a weak server
  49    oracle-weak: launch a padding oracle attack against a weak server
  50    oracle-fixed: launch a padding oracle attack against a fixed server",
  51       os::args()[0]
  52    );
  53 }
  54
  55 enum Mode {
  56    Help,
  57    ServerAlone,
  58    GenKey,
  59    Tests,
  60    OracleWeak,
  61    OracleFixed,
  62 }
  63
  64 fn mode() -> Mode {
  65    let args = os::args();
  66
  67    if args.iter().any(|a| a.as_slice() == "--help" || a.as_slice() == "-h") {
  68       return Mode::Help
  69    }
  70
  71    if args.len() <= 1 {
  72       Mode::ServerAlone
  73    } else {
  74       match args[1].as_slice() {
  75          "genkey" => Mode::GenKey,
  76          "tests" => Mode::Tests,
  77          "oracle-weak" => Mode::OracleWeak,
  78          "oracle-fixed" => Mode::OracleFixed,
  79          _ => Mode::ServerAlone,
  80       }
  81    }
  82 }
  83
  84 fn main() {
  85    let mode = mode();
  86
  87    match mode {
  88       Mode::Help => print_usage(),
  89       Mode::GenKey =>
  90          match crypto::generate_key(256 / 8) {
  91             Ok(key) => println!("key: {}", key),
  92             Err(e) => println!("Unable to generate a key. Error: {}", e)
  93          },
  94       _ => {
  95          let address = "::1";
  96          println!("Starting server on [{}]:{}...", address, PORT);
  97
  98          match Server::new(address, PORT, match mode { Mode::OracleFixed => packet::Variant::Fixed, _ => packet::Variant::Weak }) {
  99             Ok(mut server) => {
 100                println!("Server started");
 101
 102                match mode {
 103                   Mode::Tests => Client::start_tests(address, PORT, packet::Variant::Weak),
 104                   Mode::OracleWeak => do_oracle_attack(address, packet::Variant::Weak),
 105                   Mode::OracleFixed => do_oracle_attack(address, packet::Variant::Fixed),
 106                   _ => {
 107                      println!("Press any key to quit");
 108                      io::stdin().read_line().ok().expect("Failed to read line");
 109                   }
 110                }
 111
 112                server.close().ok().expect("Failed to close the server");
 113             },
 114             Err(e) =>
 115                println!("Unable to create a new server. Error: {}", e)
 116          }
 117       }
 118    }
 119 }