Rijndael Algo in Rust for CSCI412

Rijndael.rs

/*
    Rijndael in Rust
    By John P Tomanelli II
    ----------------------
*/
use std::io;

struct AES {
    key : [u8; 16],
    state : [u8;16],
}

impl AES {

    fn encrypt(&mut self) {

        let mut expanded_key : [u8;176] = [0;176];

        AES::key_expansion(self.key, &mut expanded_key);
        AES::add_round_key(&mut self.state, &expanded_key, 0);
        for i in 1..10 {
            AES::sub_bytes(&mut self.state);
            AES::shift_rows(&mut self.state);
            AES::mix_columns(&mut self.state);
            AES::add_round_key(&mut self.state, &expanded_key, (i * 16));
        }
        AES::sub_bytes(&mut self.state);
        AES::shift_rows(&mut self.state);
        AES::add_round_key(&mut self.state, &expanded_key, 160);

    }

    fn mix_columns(state : &mut [u8;16]) {
        let mut tmp_state : [u8;16] = [0;16];
        tmp_state[0] = AES::get_galois_mult(state[0] as usize, 2) ^ AES::get_galois_mult(state[1] as usize, 3) ^ state[2] ^ state[3];
        tmp_state[1] = AES::get_galois_mult(state[1] as usize, 2) ^ AES::get_galois_mult(state[2] as usize, 3) ^ state[0] ^ state[3];
        tmp_state[2] = AES::get_galois_mult(state[2] as usize, 2) ^ AES::get_galois_mult(state[3] as usize, 3) ^ state[0] ^ state[1];
        tmp_state[3] = AES::get_galois_mult(state[3] as usize, 2) ^ AES::get_galois_mult(state[0] as usize, 3) ^ state[1] ^ state[2];

        tmp_state[4] = AES::get_galois_mult(state[4] as usize, 2) ^ AES::get_galois_mult(state[5] as usize, 3) ^ state[6] ^ state[7];
        tmp_state[5] = state[4] ^ AES::get_galois_mult(state[5] as usize,2) ^ AES::get_galois_mult(state[6] as usize, 3) ^ state[7];
        tmp_state[6] = state[4] ^ state[5] ^ AES::get_galois_mult(state[6] as usize,2) ^ AES::get_galois_mult(state[7] as usize,3);
        tmp_state[7] = AES::get_galois_mult(state[4] as usize,3) ^ state[5] ^ state[6] ^ AES::get_galois_mult(state[7] as usize,2);

        tmp_state[8] = AES::get_galois_mult(state[8] as usize,2) ^ AES::get_galois_mult(state[9] as usize, 3) ^ state[10] ^ state[11];
        tmp_state[9] = state[8] ^ AES::get_galois_mult(state[9] as usize,2) ^ AES::get_galois_mult(state[10] as usize,3) ^ state[11];
        tmp_state[10] = state[8] ^ state[9] ^ AES::get_galois_mult(state[10] as usize,2) ^ AES::get_galois_mult(state[11] as usize,3);
        tmp_state[11] = AES::get_galois_mult(state[8] as usize,3) ^ state[9] ^ state[10] ^ AES::get_galois_mult(state[11] as usize,2);

        tmp_state[12] = AES::get_galois_mult(state[12] as usize, 2) ^ AES::get_galois_mult(state[13] as usize,3) ^ state[14] ^ state[15];
        tmp_state[13] = state[12] ^ AES::get_galois_mult(state[13] as usize,2) ^ AES::get_galois_mult(state[14] as usize,3) ^ state[15];
        tmp_state[14] = state[12] ^ state[13] ^ AES::get_galois_mult(state[14] as usize,2) ^ AES::get_galois_mult(state[15] as usize,3);
        tmp_state[15] = AES::get_galois_mult(state[12] as usize,3) ^ state[13] ^ state[14] ^ AES::get_galois_mult(state[15] as usize,2);

        for i in 0..16 {
            state[i] = tmp_state[i];
        }
    }

    fn shift_rows(state : &mut [u8;16]) {
        let mut tmp : [u8;16] = [0;16];
        tmp[0] = state[0];
        tmp[1] = state[5];
        tmp[2] = state[10];
        tmp[3] = state[15];

        tmp[4] = state[4];
        tmp[5] = state[9];
        tmp[6] = state[14];
        tmp[7] = state[3];

        tmp[8] = state[8];
        tmp[9] = state[13];
        tmp[10] = state[2];
        tmp[11] = state[7];

        tmp[12] = state[12];
        tmp[13] = state[1];
        tmp[14] = state[6];
        tmp[15] = state[11];

        for i in 0..16 {
            state[i] = tmp[i];
        }
    }

    fn sub_bytes(state : &mut [u8;16]) {
        for i in 0..16 {
            state[i] = AES::get_sbox_value(state[i] as usize);
        }
    }

    fn add_round_key(state : &mut [u8;16], round_key : &[u8;176], block : usize) {
        for i in 0..16 {
            state[i] ^= round_key[i + block];
        }
    }

    fn key_expansion(key : [u8;16], expanded_key : &mut [u8;176]) {
        let mut tmp : [u8;4] = [0;4];

        for i in 0..16 {
            expanded_key[i] = key[i];
        }

        let mut bytes_generated : usize = 16;
        let mut rcon_iter : usize = 1;

        while bytes_generated < expanded_key.len()  {
            for i in 0..4 {
                tmp[i] = expanded_key[i + bytes_generated - 4];
            }
            if bytes_generated % 16 == 0 {
                // CORE
                let tmp_val = tmp[0];
                tmp[0] = tmp[1];
                tmp[1] = tmp[2];
                tmp[2] = tmp[3];
                tmp[3] = tmp_val;
                tmp[0] = AES::get_sbox_value(tmp[0] as usize);
                tmp[1] = AES::get_sbox_value(tmp[1] as usize);
                tmp[2] = AES::get_sbox_value(tmp[2] as usize);
                tmp[3] = AES::get_sbox_value(tmp[3] as usize);
                tmp[0] ^= AES::get_rcon(rcon_iter);
                rcon_iter += 1;

            }
            for i in 0..4 {
                expanded_key[bytes_generated] =
                    expanded_key[bytes_generated - 16] ^ tmp[i];
                bytes_generated += 1;
            }
        }
    }

    //  RCON
    fn get_rcon(i : usize) -> u8 {
        let rcon : [u8;256] = [
            0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
            0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,
            0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
            0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
            0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
            0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
            0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
            0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
            0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
            0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
            0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
            0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
            0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
            0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
            0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
            0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d
        ];
        rcon[i]
    }

    //  Galois mult of 2 & 3
    fn get_galois_mult(i : usize, mult : usize) -> u8 {
        if mult == 2 {
            let galois_mult_2 : [u8;256] = [
                0x00,0x02,0x04,0x06,0x08,0x0a,0x0c,0x0e,0x10,0x12,0x14,0x16,0x18,0x1a,0x1c,0x1e,
                0x20,0x22,0x24,0x26,0x28,0x2a,0x2c,0x2e,0x30,0x32,0x34,0x36,0x38,0x3a,0x3c,0x3e,
                0x40,0x42,0x44,0x46,0x48,0x4a,0x4c,0x4e,0x50,0x52,0x54,0x56,0x58,0x5a,0x5c,0x5e,
                0x60,0x62,0x64,0x66,0x68,0x6a,0x6c,0x6e,0x70,0x72,0x74,0x76,0x78,0x7a,0x7c,0x7e,
                0x80,0x82,0x84,0x86,0x88,0x8a,0x8c,0x8e,0x90,0x92,0x94,0x96,0x98,0x9a,0x9c,0x9e,
                0xa0,0xa2,0xa4,0xa6,0xa8,0xaa,0xac,0xae,0xb0,0xb2,0xb4,0xb6,0xb8,0xba,0xbc,0xbe,
                0xc0,0xc2,0xc4,0xc6,0xc8,0xca,0xcc,0xce,0xd0,0xd2,0xd4,0xd6,0xd8,0xda,0xdc,0xde,
                0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec,0xee,0xf0,0xf2,0xf4,0xf6,0xf8,0xfa,0xfc,0xfe,
                0x1b,0x19,0x1f,0x1d,0x13,0x11,0x17,0x15,0x0b,0x09,0x0f,0x0d,0x03,0x01,0x07,0x05,
                0x3b,0x39,0x3f,0x3d,0x33,0x31,0x37,0x35,0x2b,0x29,0x2f,0x2d,0x23,0x21,0x27,0x25,
                0x5b,0x59,0x5f,0x5d,0x53,0x51,0x57,0x55,0x4b,0x49,0x4f,0x4d,0x43,0x41,0x47,0x45,
                0x7b,0x79,0x7f,0x7d,0x73,0x71,0x77,0x75,0x6b,0x69,0x6f,0x6d,0x63,0x61,0x67,0x65,
                0x9b,0x99,0x9f,0x9d,0x93,0x91,0x97,0x95,0x8b,0x89,0x8f,0x8d,0x83,0x81,0x87,0x85,
                0xbb,0xb9,0xbf,0xbd,0xb3,0xb1,0xb7,0xb5,0xab,0xa9,0xaf,0xad,0xa3,0xa1,0xa7,0xa5,
                0xdb,0xd9,0xdf,0xdd,0xd3,0xd1,0xd7,0xd5,0xcb,0xc9,0xcf,0xcd,0xc3,0xc1,0xc7,0xc5,
                0xfb,0xf9,0xff,0xfd,0xf3,0xf1,0xf7,0xf5,0xeb,0xe9,0xef,0xed,0xe3,0xe1,0xe7,0xe5
            ];
            galois_mult_2[i]
        }
        else if mult == 3 {
            let galois_mult_3 : [u8;256] = [
                0x00,0x03,0x06,0x05,0x0c,0x0f,0x0a,0x09,0x18,0x1b,0x1e,0x1d,0x14,0x17,0x12,0x11,
                0x30,0x33,0x36,0x35,0x3c,0x3f,0x3a,0x39,0x28,0x2b,0x2e,0x2d,0x24,0x27,0x22,0x21,
                0x60,0x63,0x66,0x65,0x6c,0x6f,0x6a,0x69,0x78,0x7b,0x7e,0x7d,0x74,0x77,0x72,0x71,
                0x50,0x53,0x56,0x55,0x5c,0x5f,0x5a,0x59,0x48,0x4b,0x4e,0x4d,0x44,0x47,0x42,0x41,
                0xc0,0xc3,0xc6,0xc5,0xcc,0xcf,0xca,0xc9,0xd8,0xdb,0xde,0xdd,0xd4,0xd7,0xd2,0xd1,
                0xf0,0xf3,0xf6,0xf5,0xfc,0xff,0xfa,0xf9,0xe8,0xeb,0xee,0xed,0xe4,0xe7,0xe2,0xe1,
                0xa0,0xa3,0xa6,0xa5,0xac,0xaf,0xaa,0xa9,0xb8,0xbb,0xbe,0xbd,0xb4,0xb7,0xb2,0xb1,
                0x90,0x93,0x96,0x95,0x9c,0x9f,0x9a,0x99,0x88,0x8b,0x8e,0x8d,0x84,0x87,0x82,0x81,
                0x9b,0x98,0x9d,0x9e,0x97,0x94,0x91,0x92,0x83,0x80,0x85,0x86,0x8f,0x8c,0x89,0x8a,
                0xab,0xa8,0xad,0xae,0xa7,0xa4,0xa1,0xa2,0xb3,0xb0,0xb5,0xb6,0xbf,0xbc,0xb9,0xba,
                0xfb,0xf8,0xfd,0xfe,0xf7,0xf4,0xf1,0xf2,0xe3,0xe0,0xe5,0xe6,0xef,0xec,0xe9,0xea,
                0xcb,0xc8,0xcd,0xce,0xc7,0xc4,0xc1,0xc2,0xd3,0xd0,0xd5,0xd6,0xdf,0xdc,0xd9,0xda,
                0x5b,0x58,0x5d,0x5e,0x57,0x54,0x51,0x52,0x43,0x40,0x45,0x46,0x4f,0x4c,0x49,0x4a,
                0x6b,0x68,0x6d,0x6e,0x67,0x64,0x61,0x62,0x73,0x70,0x75,0x76,0x7f,0x7c,0x79,0x7a,
                0x3b,0x38,0x3d,0x3e,0x37,0x34,0x31,0x32,0x23,0x20,0x25,0x26,0x2f,0x2c,0x29,0x2a,
                0x0b,0x08,0x0d,0x0e,0x07,0x04,0x01,0x02,0x13,0x10,0x15,0x16,0x1f,0x1c,0x19,0x1a
            ];
            galois_mult_3[i]
        }
        else {
            panic!("ERROR");
        }
    }

    //  Sbox values
    fn get_sbox_value(i : usize) -> u8 {
        let sbox : [u8;256] = [

        0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
        0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
        0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
        0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
        0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
        0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
        0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
        0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
        0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
        0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
        0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
        0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
        0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
        0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
        0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
        0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 ];
        sbox[i]
        //  Test bounds
    }
}

struct ByteBuf<'a>(&'a [u8]);
impl<'a> std::fmt::LowerHex for ByteBuf<'a> {
    fn fmt(&self, fmtr: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        for byte in self.0 {
            try!( fmtr.write_fmt(format_args!("{:02x} ", byte)));
        }
        Ok(())
    }
}
/*
if (paddedLen % 16 == 0)
  paddedLen = (paddedLen / 16 + 1) * 16;
unsigned char *paddedMessage = new unsigned char[paddedLen];
for (int i=0;i<paddedLen; i++) {
  if (i >= orgLen) paddedMessage[i] = 0;
  else paddedMessage[i] = message[i];
}

for (int i=0; i < paddedLen; i++) {
    AES_Encrypt(paddedMessage+i,key);
}
cout << "\nEncrypted message: " << endl;
for (int i=0;i<paddedLen; i++) {
  cout <<  paddedMessage[i] ;
  cout << " ";
}
*/

fn get_plaintext() -> [u8;16] {
    println!("Enter Plaintext : ");
    let mut input = String::new();
    let mut state : [u8;16] = [0;16];
    match io::stdin().read_line(&mut input) {
        Ok(n) => {
            let mut i = 0;
            print!("State : ");
            for byte in input.as_bytes() {
                //  For removing NULL - better way?
                if i+1 <= n -1 && i < 16 {
                    state[i] = *byte;
                    print!("{:?} ", byte);
                }
                i+=1;
            }
            println!("\nState in Hex: {:x} ", ByteBuf(&state));
            println!("----------------------------------------------------");
        }
        Err(err) => { println!("{:?}", err); }
    }
    state
}


fn main() {

    let mut aes = AES {
        key : [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] ,
        state : get_plaintext(),
    };

    println!("Key: {:?}", aes.key);
    aes.encrypt();
    println!("State: {:?}", aes.state);
    println!("State in Hex: {:x} ", ByteBuf(&aes.state));
}

AES implementation (pure Rust): https://github.com/LuoZijun/crypto/blob/master/src/aes/generic.rs