S-DESの暗号化をRustで実装してみた

use std::fs;

fn main() {
    let (key1, key2) = generate_key(0b1010000010);

    let plain_text = fs::read("./plain.txt").unwrap();

    let encrypted_text = plain_text
        .iter()
        .map(|char| encrypt(char.clone(), key1, key2))
        .collect::<Vec<_>>();

    fs::write("./cipher.txt", encrypted_text).unwrap();
}

fn encrypt(plain_text: u8, key1: u8, key2: u8) -> u8 {
    let after_ip = initial_permutation(plain_text);
    let after_fx = fx(key1, after_ip);
    let after_part1 = swap_8bit(after_fx);
    let after_fx = fx(key2, after_part1);
    let result = reverse_initial_permutation(after_fx);
    result
}

fn fx(key: u8, input: u8) -> u8 {
    let [left_ip, right_ip] = split_8bit(input);

    let after_ep = expanded_permutation(right_ip);

    let after_ep_xor_key = key ^ after_ep;
    let [left_ep, right_ep] = split_8bit(after_ep_xor_key);

    let left_sbox = sbox_left(left_ep);
    let right_sbox = sbox_right(right_ep);
    let after_sbox = left_sbox << 2 | right_sbox;

    let after_p4 = p4_permutation(after_sbox);

    let after_p4_xor = after_p4 ^ left_ip;
    let result = (after_p4_xor << 4) | right_ip;

    return result;
}

fn swap_8bit(data: u8) -> u8 {
    return (data >> 4) | ((data << 4) & 0b11110000);
}

fn initial_permutation(data: u8) -> u8 {
    let bit8 = is_true_bit(data as u16, 0) as u8;
    let bit7 = is_true_bit(data as u16, 1) as u8;
    let bit6 = is_true_bit(data as u16, 2) as u8;
    let bit5 = is_true_bit(data as u16, 3) as u8;
    let bit4 = is_true_bit(data as u16, 4) as u8;
    let bit3 = is_true_bit(data as u16, 5) as u8;
    let bit2 = is_true_bit(data as u16, 6) as u8;
    let bit1 = is_true_bit(data as u16, 7) as u8;

    return (bit7)
        | bit5 << 1
        | bit8 << 2
        | bit4 << 3
        | bit1 << 4
        | bit3 << 5
        | bit6 << 6
        | bit2 << 7;
}

fn reverse_initial_permutation(data: u8) -> u8 {
    let bit8 = is_true_bit(data as u16, 0) as u8;
    let bit7 = is_true_bit(data as u16, 1) as u8;
    let bit6 = is_true_bit(data as u16, 2) as u8;
    let bit5 = is_true_bit(data as u16, 3) as u8;
    let bit4 = is_true_bit(data as u16, 4) as u8;
    let bit3 = is_true_bit(data as u16, 5) as u8;
    let bit2 = is_true_bit(data as u16, 6) as u8;
    let bit1 = is_true_bit(data as u16, 7) as u8;

    return (bit6)
        | bit8 << 1
        | bit2 << 2
        | bit7 << 3
        | bit5 << 4
        | bit3 << 5
        | bit1 << 6
        | bit4 << 7;
}

fn expanded_permutation(data: u8) -> u8 {
    let bit4 = is_true_bit(data as u16, 0) as u8;
    let bit3 = is_true_bit(data as u16, 1) as u8;
    let bit2 = is_true_bit(data as u16, 2) as u8;
    let bit1 = is_true_bit(data as u16, 3) as u8;

    return (bit1)
        | bit4 << 1
        | bit3 << 2
        | bit2 << 3
        | bit3 << 4
        | bit2 << 5
        | bit1 << 6
        | bit4 << 7;
}

fn sbox_left(data: u8) -> u8 {
    let sbox0 = [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]];
    let row = ((data & (1 << 3)) >> 2) | (data & 1);
    let column = ((data & (1 << 2)) >> 1) | ((data & (1 << 1)) >> 1);
    return sbox0[row as usize][column as usize];
}

fn sbox_right(data: u8) -> u8 {
    let sbox1 = [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]];
    let row = ((data & (1 << 3)) >> 2) | (data & 1);
    let column = ((data & (1 << 2)) >> 1) | ((data & (1 << 1)) >> 1);
    return sbox1[row as usize][column as usize];
}

fn p4_permutation(data: u8) -> u8 {
    let bit_4 = is_true_bit(data as u16, 0) as u8;
    let bit_3 = is_true_bit(data as u16, 1) as u8;
    let bit_2 = is_true_bit(data as u16, 2) as u8;
    let bit_1 = is_true_bit(data as u16, 3) as u8;

    return (bit_1) | bit_3 << 1 | bit_4 << 2 | bit_2 << 3;
}

fn split_8bit(data: u8) -> [u8; 2] {
    let left = data >> 4;
    let right = data & 0b00001111;
    [left, right]
}

fn is_true_bit(key: u16, bit: u8) -> bool {
    (key & 1 << bit) != 0
}