crypto.cipher #

Use of this source code is governed by an MIT license that can be found in the LICENSE file. Cipher block chaining (CBC) mode. CBC provides confidentiality by xoring (chaining) each plaintext block with the previous ciphertext block before applying the block cipher. See NIST SP 800-38A, pp 10-11 NOTE this will be moved to crypto.cipher interface (joe-c)

fn new_cbc(b Block, iv []u8) Cbc

new_cbc returns a DesCbc which encrypts in cipher block chaining mode, using the given Block. The length of iv must be the same as the Block's block size.

fn new_cfb_decrypter(b Block, iv []u8) Cfb

new_cfb_decrypter returns a Cfb which decrypts with cipher feedback mode, using the given Block. The iv must be the same length as the Block's block size

fn new_cfb_encrypter(b Block, iv []u8) Cfb

new_cfb_encrypter returns a Cfb which encrypts with cipher feedback mode, using the given Block. The iv must be the same length as the Block's block size

fn new_ctr(b Block, iv []u8) Ctr

new_ctr returns a Ctr which encrypts/decrypts using the given Block in counter mode. The length of iv must be the same as the Block's block size.

fn new_ofb(b Block, iv []u8) Ofb

new_ofb returns a Ofb that encrypts or decrypts using the block cipher b in output feedback mode. The initialization vector iv's length must be equal to b's block size.

fn safe_xor_bytes(mut dst []u8, a []u8, b []u8, n int)

safe_xor_bytes XORs the bytes in a and b into dst it does so n times. Please note: n needs to be smaller or equal than the length of a and b.

fn xor_bytes(mut dst []u8, a []u8, b []u8) int

Note: Implement other versions (joe-c)xor_bytes xors the bytes in a and b. The destination should have enough space, otherwise xor_bytes will panic. Returns the number of bytes xor'd.

fn xor_words(mut dst []u8, a []u8, b []u8)

xor_words XORs multiples of 4 or 8 bytes (depending on architecture.) The slice arguments a and b are assumed to be of equal length.

interface AEAD {
	// nonce_size returns the size of nonce (in bytes) used by this AEAD that must be
	// passed to `.encrypt` or `.decrypt`.
	nonce_size() int
	// overhead returns the maximum difference between the lengths of a plaintext and its ciphertext.
	overhead() int
	// encrypt encrypts and authenticates the provided plaintext along with the nonce and
	// additional data in `ad`. The nonce must be `nonce_size()` bytes long and unique
	// for all time, for a given key. It returns encrypted (and authenticated) ciphertext bytes
	// where its encoded form is up to implementation and not dictated by the interfaces.
	// Commonly, its contains encrypted text plus some authentication tag, and maybe some other bytes.
	encrypt(plaintext []u8, nonce []u8, ad []u8) ![]u8
	// decrypt decrypts and authenticates (verifies) the provided ciphertext along with a nonce, and
	// additional data. The nonce must be `nonce_size()` bytes long and both it and the additional data
	// must match the value passed to `encrypt`.
	// Its returns the verified plaintext on success, or errors on fails.
	decrypt(ciphertext []u8, nonce []u8, ad []u8) ![]u8
}

AEAD provides an authenticated encryption with associated data for encryption (decryption).

interface Block {
	block_size int // block_size returns the cipher's block size.
	encrypt(mut dst []u8, src []u8) // Encrypt encrypts the first block in src into dst.
	// Dst and src must overlap entirely or not at all.
	decrypt(mut dst []u8, src []u8) // Decrypt decrypts the first block in src into dst.
	// Dst and src must overlap entirely or not at all.
}

A Block represents an implementation of block cipher using a given key. It provides the capability to encrypt or decrypt individual blocks. The mode implementations extend that capability to streams of blocks.

interface BlockMode {
	block_size int // block_size returns the mode's block size.
	crypt_blocks(mut dst []u8, src []u8) // crypt_blocks encrypts or decrypts a number of blocks. The length of
	// src must be a multiple of the block size. Dst and src must overlap
	// entirely or not at all.
	//
	// If len(dst) < len(src), crypt_blocks should panic. It is acceptable
	// to pass a dst bigger than src, and in that case, crypt_blocks will
	// only update dst[:len(src)] and will not touch the rest of dst.
	//
	// Multiple calls to crypt_blocks behave as if the concatenation of
	// the src buffers was passed in a single run. That is, BlockMode
	// maintains state and does not reset at each crypt_blocks call.
}

A BlockMode represents a block cipher running in a block-based mode (CBC, ECB etc).

interface Stream {
	// xor_key_stream XORs each byte in the given slice with a byte from the
	// cipher's key stream. Dst and src must overlap entirely or not at all.
	//
	// If len(dst) < len(src), xor_key_stream should panic. It is acceptable
	// to pass a dst bigger than src, and in that case, xor_key_stream will
	// only update dst[:len(src)] and will not touch the rest of dst.
	//
	// Multiple calls to xor_key_stream behave as if the concatenation of
	// the src buffers was passed in a single run. That is, Stream
	// maintains state and does not reset at each xor_key_stream call.
mut:
	xor_key_stream(mut dst []u8, src []u8)
}

A Stream represents a stream cipher.

fn (mut x Cbc) free()

free the resources taken by the Cbc x

fn (mut x Cbc) encrypt_blocks(mut dst_ []u8, src_ []u8)

encrypt_blocks encrypts the blocks in src_ to dst_. Please note: dst_ is mutable for performance reasons.

fn (mut x Cbc) decrypt_blocks(mut dst []u8, src []u8)

decrypt_blocks decrypts the blocks in src to dst. Please note: dst is mutable for performance reasons.

fn (mut x Cfb) free()

free the resources taken by the Cfb x

fn (mut x Cfb) xor_key_stream(mut dst []u8, src []u8)

xor_key_stream xors each byte in the given slice with a byte from the key stream.

fn (mut x Ctr) free()

free the resources taken by the Ctr c

fn (mut x Ctr) xor_key_stream(mut dst []u8, src []u8)

xor_key_stream xors each byte in the given slice with a byte from the key stream.

fn (mut x Ofb) xor_key_stream(mut dst []u8, src []u8)

xor_key_stream xors each byte in the given slice with a byte from the key stream.