167 lines
4.9 KiB
Rust
167 lines
4.9 KiB
Rust
use rand::Rng;
|
|
use std::fmt::Write;
|
|
|
|
#[derive(PartialEq, Eq, PartialOrd, Debug)]
|
|
pub struct Bytes(pub Vec<u8>);
|
|
|
|
impl Bytes {
|
|
pub fn from_utf8(s: &str) -> Bytes {
|
|
Bytes(s.as_bytes().to_vec())
|
|
}
|
|
|
|
pub fn to_utf8(&self) -> String {
|
|
let Bytes(v) = self;
|
|
String::from(std::str::from_utf8(v).unwrap())
|
|
}
|
|
|
|
pub fn len(&self) -> usize {
|
|
self.0.len()
|
|
}
|
|
|
|
pub fn get_block(&self, block_index: usize, block_size: usize) -> Bytes {
|
|
Bytes(self.0[(block_index * block_size)..(block_index + 1) * block_size].to_vec())
|
|
}
|
|
|
|
pub fn random(length: usize) -> Bytes {
|
|
Bytes(
|
|
(0..length)
|
|
.map(|_| rand::thread_rng().gen_range(0..255))
|
|
.collect(),
|
|
)
|
|
}
|
|
|
|
pub fn random_range(lower: usize, upper: usize) -> Bytes {
|
|
let length: usize = rand::thread_rng().gen_range(lower..upper);
|
|
Bytes::random(length)
|
|
}
|
|
|
|
pub fn from_hex(s: &str) -> Bytes {
|
|
assert!(
|
|
s.len() % 2 == 0,
|
|
"Input string has uneven number of characters"
|
|
);
|
|
let bytes_result: Result<Vec<u8>, std::num::ParseIntError> = (0..s.len())
|
|
.step_by(2)
|
|
.map(|i| u8::from_str_radix(&s[i..i + 2], 16))
|
|
.collect();
|
|
|
|
Bytes(bytes_result.expect("Invalid hex string"))
|
|
}
|
|
|
|
pub fn to_hex(&self) -> String {
|
|
let Bytes(v) = self;
|
|
let mut r = String::new();
|
|
for e in v.iter() {
|
|
write!(r, "{:02x}", e).unwrap();
|
|
}
|
|
r
|
|
}
|
|
|
|
pub fn ascii_score(&self) -> u32 {
|
|
let Bytes(v) = self;
|
|
let mut r = 0;
|
|
for &c in v.iter() {
|
|
match c {
|
|
b'!'..=b'@' | b'['..=b'`' | b'{'..=b'~' => r += 1,
|
|
b' ' => r += 2,
|
|
b'A'..=b'Z' | b'a'..=b'z' => r += 3,
|
|
_ => (),
|
|
}
|
|
}
|
|
r
|
|
}
|
|
|
|
pub fn guess_key(&self) -> u8 {
|
|
// Assuming all bytes have been xor-encrypted by the same u8 key, find that key
|
|
// by trying all u8 values and compute an ascii score for the resulting "plaintext".
|
|
// The u8 key for the "plaintext" with the highest score is returned as the guessed
|
|
// key.
|
|
let mut h: Vec<(Bytes, u8)> = (0..=255).map(|i| (Bytes::xor_byte(self, i), i)).collect();
|
|
h.sort_by(|a, b| a.0.ascii_score().partial_cmp(&b.0.ascii_score()).unwrap());
|
|
h.last().unwrap().1
|
|
}
|
|
|
|
pub fn pad_pkcs7(&mut self, block_size: usize) {
|
|
let Bytes(v) = self;
|
|
let padding_value = (block_size - v.len() % block_size)
|
|
.try_into()
|
|
.expect("Padding value has to be an u8");
|
|
for _ in 0..padding_value {
|
|
v.push(padding_value);
|
|
}
|
|
}
|
|
|
|
pub fn has_valid_pkcs7(&self, block_size: usize) -> bool {
|
|
if self.len() > 0 && self.len() % block_size != 0 {
|
|
return false;
|
|
}
|
|
let last_block_index = self.len() / block_size - 1;
|
|
let last_block = self.get_block(last_block_index, block_size).0;
|
|
let pad_byte = last_block[block_size - 1];
|
|
if !(1..=16).contains(&pad_byte) {
|
|
return false;
|
|
}
|
|
for i in 0..(pad_byte as usize) {
|
|
let byte = last_block[block_size - 1 - i];
|
|
if byte != pad_byte {
|
|
return false;
|
|
}
|
|
}
|
|
true
|
|
}
|
|
|
|
pub fn remove_pkcs7(&mut self, block_size: usize) {
|
|
if !self.has_valid_pkcs7(block_size) {
|
|
return;
|
|
}
|
|
let Bytes(v) = self;
|
|
let pad_byte_count = v[v.len() - 1];
|
|
for _ in 0..(pad_byte_count as usize) {
|
|
v.pop();
|
|
}
|
|
}
|
|
|
|
pub fn flip_bit(&mut self, byte_index: usize, bit_index: usize) {
|
|
let Bytes(v) = self;
|
|
let flip_mask: u8 = 0b1 << bit_index;
|
|
v[byte_index] ^= flip_mask;
|
|
}
|
|
|
|
pub fn xor(Bytes(a): &Bytes, Bytes(b): &Bytes) -> Bytes {
|
|
Bytes(crate::utils::xor(a, b))
|
|
}
|
|
|
|
pub fn xor_byte(Bytes(a): &Bytes, byte: u8) -> Bytes {
|
|
Bytes(a.iter().map(|e| e ^ byte).collect())
|
|
}
|
|
|
|
pub fn xor_cycle(Bytes(msg): &Bytes, Bytes(key): &Bytes) -> Bytes {
|
|
Bytes(
|
|
Iterator::zip(msg.iter(), 0..msg.len())
|
|
.map(|z| *(z.0) ^ key[z.1 % key.len()])
|
|
.collect(),
|
|
)
|
|
}
|
|
|
|
pub fn has_duplicated_cycle(&self, block_size: usize) -> bool {
|
|
let Bytes(v) = self;
|
|
let chunks: Vec<&[u8]> = v.chunks(block_size).collect();
|
|
// we could use a hashmap to get O(n) instead of O(n^2)
|
|
for i in 0..chunks.len() {
|
|
for j in (i + 1)..chunks.len() {
|
|
if chunks[i] == chunks[j] {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
pub fn hemming(Bytes(a): &Bytes, Bytes(b): &Bytes) -> u32 {
|
|
let v: Vec<u32> = Iterator::zip(a.iter(), b.iter())
|
|
.map(|z| (*(z.0) ^ *(z.1)).count_ones())
|
|
.collect();
|
|
v.iter().sum()
|
|
}
|
|
}
|