felixm/cryptopals
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Resolve more linter warnings

Browse Source
This commit is contained in:
Felix Martin
2022-08-27 14:47:56 -04:00
parent 0951a6ab3e
commit bac75acd2c
14 changed files with 175 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/set2.rs
View File

@@ -50,7 +50,7 @@ pub fn challenge11() {
let key = Bytes::random(16);
// Under the hood, have the function append 5-10 bytes (count chosen randomly)
// before the plaintext and 5-10 bytes after the plaintext.
let padded_data = pad_data(data.to_vec());
let padded_data = pad_data(data.clone());
// Now, have the function choose to encrypt under ECB 1/2 the time, and under CBC
// the other half (just use random IVs each time for CBC). Use rand(2) to decide
// which to use.
@@ -103,7 +103,7 @@ pub fn challenge12() {
fn encryption_oracle(key: &Bytes, Bytes(data): &Bytes) -> Bytes {
// Copy your oracle function to a new function that encrypts buffers under ECB mode using a consistent but unknown key
// Now take that same function and have it append to the plaintext, BEFORE ENCRYPTING, the following string (from 12.txt):
let mut data = data.to_vec();
let mut data = data.clone();
let mut string = utils::read_base64("data/12.txt");
data.append(&mut string.0);
ecb::encrypt(key, &Bytes(data))
@@ -112,11 +112,11 @@ pub fn challenge12() {
fn get_block_size(key: &Bytes) -> usize {
// Detect cipher block size
let mut v = vec![];
let initial_cipher_len = encryption_oracle(key, &Bytes(v.to_vec())).0.len();
let initial_cipher_len = encryption_oracle(key, &Bytes(v.clone())).0.len();
let mut new_cipher_len = initial_cipher_len;
while initial_cipher_len == new_cipher_len {
v.push(b'A');
let cipher = encryption_oracle(key, &Bytes(v.to_vec()));
let cipher = encryption_oracle(key, &Bytes(v.clone()));
new_cipher_len = cipher.0.len();
}
new_cipher_len - initial_cipher_len
@@ -137,20 +137,20 @@ pub fn challenge12() {
let mut cleartext_block = vec![];
for padding_length in (0..block_size).rev() {
let padding_text = vec![b'-'; padding_length];
let expected = encryption_oracle(key, &Bytes(padding_text.to_vec()));
let expected = encryption_oracle(key, &Bytes(padding_text.clone()));
let expected_block = expected.get_block(block_index, block_size);
let mut known_text = if block_index == 0 {
padding_text.to_vec()
padding_text.clone()
} else {
let cleartext_offset =
((block_index - 1) * block_size) + (block_size - padding_length);
cleartext[cleartext_offset..(cleartext_offset + padding_length)].to_vec()
};
known_text.append(&mut cleartext_block.to_vec());
known_text.append(&mut cleartext_block.clone());
for i in 0..255 {
let mut guess_text = known_text.to_vec();
let mut guess_text = known_text.clone();
guess_text.push(i);
let cipher_block =
encryption_oracle(key, &Bytes(guess_text)).get_block(0, block_size);
@@ -183,9 +183,11 @@ pub fn challenge13() {
fn profile_for(input: &str, key: &Bytes) -> Bytes {
let mut r = String::new();
for c in input.chars() {
if !(c.is_ascii_alphabetic() || c == '.' || c == '@') {
panic!("profile_for: invalid char {}", c);
}
assert!(
c.is_ascii_alphabetic() || c == '.' || c == '@',
"profile_for: invalid char {}",
c
);
}
r.push_str("email=");
r.push_str(input);
@@ -246,8 +248,8 @@ pub fn challenge14() {
// know how to decode it because I cannot really run experiments. If I generate
// a single random prefix it becomes rather trivial. I just have to find out how
// long it is and then adjust the decoding routine.
let mut plaintext = random_prefix.to_vec();
plaintext.append(&mut attacker_controlled.to_vec());
let mut plaintext = random_prefix.clone();
plaintext.append(&mut attacker_controlled.clone());
let mut target_bytes = utils::read_base64("data/12.txt").0;
plaintext.append(&mut target_bytes);
ecb::encrypt(random_key, &Bytes(plaintext))
@@ -285,7 +287,7 @@ pub fn challenge14() {
for i in 0..block_size {
let mut padding = vec![b'a'; i];
padding.append(&mut duplicated_text.to_vec());
padding.append(&mut duplicated_text.clone());
let cipher = encryption_oracle(prefix, key, &Bytes(padding));
if let Some((first_block, _)) = get_duplicated_block_indices(&cipher, block_size) {
return block_size * first_block - i;
@@ -313,11 +315,11 @@ pub fn challenge14() {
let mut cleartext_block = vec![];
for padding_length in (0..block_size).rev() {
let full_padding_text = vec![b'-'; prefix_padding_size + padding_length];
let expected = encryption_oracle(prefix, key, &Bytes(full_padding_text.to_vec()));
let expected = encryption_oracle(prefix, key, &Bytes(full_padding_text.clone()));
let expected_block = expected.get_block(block_index, block_size);
let mut known_text = if block_index == first_block_index {
full_padding_text.to_vec()
full_padding_text.clone()
} else {
let mut prefix_padding = vec![b'-'; prefix_padding_size];
let cleartext_offset = ((block_index - first_block_index - 1) * block_size)
@@ -328,10 +330,10 @@ pub fn challenge14() {
);
prefix_padding
};
known_text.append(&mut cleartext_block.to_vec());
known_text.append(&mut cleartext_block.clone());
for i in 0..255 {
let mut guess_text = known_text.to_vec();
let mut guess_text = known_text.clone();
guess_text.push(i);
let cipher_block = encryption_oracle(prefix, key, &Bytes(guess_text))
.get_block(first_block_index, block_size);
@@ -373,9 +375,7 @@ pub fn challenge16() {
fn encrypt(input: &str, key: &Bytes, iv: &Bytes) -> Bytes {
let mut r = String::new();
for c in input.chars() {
if c == ';' || c == '=' {
panic!("encrypt: invalid char {}", c);
}
assert!(c != ';' && c != '=', "encrypt: invalid char {}", c);
}
r.push_str("comment1=cooking%20MCs;userdata=");
r.push_str(input);