cipher is immutable but its method takes mutable self

[rustcrypto]

cipher is immutable but its method takes mutable self

[tarcieri]

It consumes self. The mut is an implementation detail of the local binding after self is consumed.

[keepsimple1]

I didn't know Rust allow that. That said, why consumes self? why not using a reference?

The types that implement this trait might not be Copy. with the current method, it could cause problems when cipher is part of a struct, when the struct itself is not moved.

And looking more closely, encrypt_vec actually calls encrypt_blocks which takes &mut self , not consuming self:

block-ciphers/block-modes/src/traits.rs

Line 39 in bc219f9

fn encrypt_blocks(&mut self, blocks: &mut [Block<C>]);

[tarcieri]

Because CBC mode requires padding for security. The one-shot API prevents misuse.

it could cause problems when cipher is part of a struct

Clone the cipher type before instantiating it.

[newpavlov]

Note that creation of block modes from ciphers is a really cheap operation and cloning a cipher instance is not too costly either.

But nevertheless, I wonder if we can add impl<T: BlockCipher> BlockCipher for &T, this could make it possible to instantiate a block mode using block cipher reference (although we would have to slightly change BlockCipher definition to accommodate for that).

[keepsimple1]

Because CBC mode requires padding for security. The one-shot API prevents misuse.

I don't understand. It seems padding is done using the buf / block, not self:

block-ciphers/block-modes/src/traits.rs

Lines 77 to 85 in bc219f9

	// prepare space for padding
	let block: Block<C> = Default::default();
	buf.extend_from_slice(&block[..n - pos]);
	let n = P::pad(&mut buf, pos, bs)
	.expect("enough space for padding is allocated")
	.len();
	buf.truncate(n);
	self.encrypt_blocks(to_blocks(&mut buf));

Maybe I'm missing something?

[tarcieri]

For security reasons:

• IVs cannot be reused.
• the last block encrypted must be padded.

The encryptor is stateful, and for e.g. CBC mode begins with an IV and then uses the previous (encrypted) block as the IV of the next.

There's no further secure operations possible after completing CBC mode encryption. If we were to reset the instance, it would let you reuse an IV. You can't add any more blocks, because padding is used to signal the end of the message.

If you want to encrypt a new message, you must start over with a new IV.