ascon

ascon is an implementation of Ascon-Based Cryptography module implemented in pure V language. This module was mostly based on NIST Special Publication of 800 NIST SP 800-232 document. Its describes an Ascon-Based Lightweight Cryptography Standards for Constrained Devices thats provides Authenticated Encryption, Hash, and Extendable Output Functions. See the NIST.SP.800-232 Standard for more detail.

This module mostly implements all the features availables on the document. It currently implements:- Ascon-Hash256, Ascon-based hashing implementation that produces 256-bits output.

• Ascon-XOF128, Ascon-based eXtendable Output Function (XOF) where the output size ofthe hash of the message can be selected by the user.- Ascon-CXOF128, a customized XOF that allows users to specify a customizationstring and choose the output size of the message hash.- Ascon-AEAD128, an Authenticated Encryption with Additional Data (AEAD) Scheme basedon Ascon-family crypto.

fn cxof128(msg []u8, size int, cs []u8) ![]u8

cxof128 creates an Ascon-CXOF128 checksum of msg with supplied size and custom string cs.

fn cxof128_64(msg []u8, cs []u8) ![]u8

cxof128_64 creates a 64-bytes of Ascon-CXOF128 checksum of msg with supplied custom string in cs.

fn decrypt(key []u8, nonce []u8, ad []u8, ciphertext []u8) ![]u8

decrypt decrypts authenticated encrypted messages in ciphertext that encrypted under provided key and nonce with additional data in ad. It would check if authentication tag mas matching and return decrypted message if success or error on fails.

fn encrypt(key []u8, nonce []u8, ad []u8, msg []u8) ![]u8

encrypt encrypts the message under provided key and nonce and supplied additional data in ad. It returns an authenticated output of Ascon-AEAD128 ciphertext where authentication tag was stored within the end of ciphertext.

Note: The Ascon-AEAD128 key shall be kept secret,

fn new_aead128(key []u8) !&Aead128

new_aead128 creates a new Aead128 instance and initialized with supplied key.

fn new_cxof128(size int, cs []u8) !&CXof128

new_cxof128 creates a new Ascon-CXOF128 instanace with cheksum size was set to size and custom string in cs. It returns error on fails.

fn new_hash256() &Hash256

new_hash256 creates a new Ascon-Hash256 instance.

fn new_xof128(size int) &Xof128

new_xof128 creates a new Ascon-XOF128 instance with provided size parameter.

fn sum256(msg_ []u8) []u8

sum256 creates an Ascon-Hash256 checksum for bytes on msg and produces a 256-bit hash.

fn xof128(msg []u8, size int) ![]u8

xof128 creates an Ascon-XOF128 checksum of msg with specified desired size of output.

fn xof128_64(msg []u8) ![]u8

xof128_64 creates a 64-bytes of Ascon-XOF128 checksum of msg.

struct Aead128 {
	State
mut:
	// 32-bytes of underlying key
	key [2]u64
}

Aead128 is an opaque provides an implementation of Ascon-AEAD128 from NIST.SP.800-232 standard. Its implements x.crypto.chacha20poly1305.AEAD interfaces.

fn (c &Aead128) nonce_size() int

nonce_size returns the nonce size of Ascon-AEAD128 Aead128.

fn (c &Aead128) overhead() int

overhead returns the maximum difference between the lengths of a plaintext and its ciphertext.

fn (mut c Aead128) encrypt(msg []u8, nonce []u8, ad []u8) ![]u8

encrypt encrypts the message under provided key and nonce and supplied additional data in ad. It returns an authenticated output of Ascon-AEAD128 ciphertext where authentication tag was stored within the end of ciphertext.

fn (mut c Aead128) decrypt(ciphertext []u8, nonce []u8, ad []u8) ![]u8

decrypt decrypts the ciphertext and validates authentication tag with provided nonce and additional data ad. It returns error on fails or tag unmatching.

struct CXof128 {
	Digest
mut:
	// Customization string
	cs []u8
	// checksum size, for fixed-output
	size int = default_xof_size
}

CXof128 is an opaque provides an implementation of Ascon-CXOF128 from NIST.SP.800-232 standard. Its implements hash.Hash interface with checksum-size stored on instance creation.

fn (x &CXof128) size() int

size returns an underlying size of CXof128 checksum in fixed-sized manner. Internally, its return underlying size stored on current CXof128 instance.

fn (x &CXof128) block_size() int

block_size returns an underlying CXof128 block size operates on, ie, 8-bytes

fn (mut x CXof128) write(msg []u8) !int

write writes out the content of message and updates internal CXof128 state.

fn (mut x CXof128) sum(msg []u8) []u8

sum returns an Ascon-CXOF128 checksum of the bytes in msg. Its produces x.size of checksum bytes. If you want to more extendible output, use .read call instead.

fn (mut x CXof128) read(mut dst []u8) !int

read tries to read dst.len bytes of hash output from current CXof128 state and stored into dst.

fn (mut x CXof128) reset()

reset resets internal CXof128 state into default initialized state.

fn (mut x CXof128) free()

free releases out the resources taken by the x. Dont use x after .free call.

struct Hash256 {
	Digest
}

Hash256 is an opaque provides an implementation of Ascon-Hash256 from NIST.SP.800-232 standard. Its implements hash.Hash interface.

fn (h &Hash256) size() int

size returns an underlying size of Hash256 checksum, ie, 32-bytes

fn (h &Hash256) block_size() int

block_size returns an underlying Hash256 block size operates on, ie, 8-bytes

fn (mut h Hash256) reset()

reset resets and reinit internal Hash256 state into default initialized state.

fn (mut h Hash256) free()

free releases out the resources taken by the h. Dont use x after .free call.

fn (mut h Hash256) write(msg []u8) !int

write writes out the content of message and updates internal Hash256 state.

fn (mut h Hash256) sum(data []u8) []u8

sum returns an Ascon-Hash256 checksum of the bytes in data.

struct Xof128 {
	Digest
mut:
	// The size of Xof128 cheksum, when you dont specify it
	size int = default_xof_size
}

Xof128 is an opaque provides an implementation of Ascon-XOF128 from NIST.SP.800-232 standard. Its implements hash.Hash interface with checksum size stored on instance creation.

fn (x &Xof128) size() int

size returns an underlying size of Xof128 checksum in fixed-sized manner. Internally, its return underlying size stored on current Xof128 instance.

fn (x &Xof128) block_size() int

block_size returns an underlying Xof128 block size operates on, ie, 8-bytes

fn (mut x Xof128) write(msg []u8) !int

write writes out the content of message and updates internal Xof128 state.

fn (mut x Xof128) sum(msg []u8) []u8

sum returns an Ascon-XOF128 checksum of the bytes in msg. Its produces x.size of checksum bytes. If you want to more extendible output, use .read call instead.

fn (mut x Xof128) read(mut dst []u8) !int

read tries to read dst.len bytes of hash output from current Xof128 state and stored into dst.

Note: 1 ≤ dst.len ≤ max_hash_size.

fn (mut x Xof128) reset()

reset resets internal Xof128 state into default initialized state.

fn (mut x Xof128) free()

free releases out the resources taken by the x. Dont use x after .free call.