Chaskey is a lightweight 128-bit encryption algorithm (please follow this link for details http://mouha.be/chaskey/)
This project provides C++ and JavaScript implementations of Chaskey algorithm with two modes of operations: CBC and MAC.
Design of both C++ and JavaScript versions follows high-granular decomposition on the following abstractions:

• Block – a block of bits stored as an array of integers (32x4)
• Formatter – formats input string of bits as blocks, either buffering them or with zero-copy direct access
• Cipher – implements forward and reverse transformations of the underlying block
• Cbc – Cipher Block Chaining mode of operation
• Mac – Message Authentication mode of operation
• Cloc – Confidentiality and Authentication mode of operation, see https://eprint.iacr.org/2014/157.pdf

In C++ primitives are implemented as templates, so that a cipher instance ultimately appears as Cbc<Cipher<N>,Formatter> or Mac<Cipher<N>,Formatter>, where N is a number of transformation rounds, set equal to 8 in Chaskey8 class.
In JavaScript same primitives are implemented as objects . Online demo is available on http://hutorny.in.ua/chaskey/

#inlcude <chaskey.hpp>


// MAC
crypto::chaskey::Cipher8::Mac mac;	// instantiate a cipher in MAC mode 
mac.set(key);						// set the key
mac.init();							// init  cipher if instance is reused
mac.update(message,length,false);	// make as many calls as needed with any message length 
mac.update(message,length,true);	// make one final call 
mac.write(ouput);					// write signature to the output or 	
mac.verify(tag);					// verify against a signature

// CBC
crypto::chaskey::Cipher8::Cbc cbc;	// instantiate a cipher in CBC mode
cbc.set(key);						// set the key
cbc.init(nonce, strlen(nonce));		// init  cipher with a nonce 
while(in) {							
	char msg[chunk_size];			 
	size_t len = in.read(msg,sizeof(msg)).gcount(); 		// read input by chunks
	cbc.encrypt(out, (const uint8_t*)msg, len, in.eof());	// and encrypt or
	//cbc.encrypt(out, (const uint8_t*)msg, len, in.eof());	// decrypt data
}

// CLOC
crypto::chaskey::Cipher8::Cloc cloc;	// instantiate a cipher in CLOC mode
cloc.set(key);							// set the key
cloc.init(); 							// inity before  reusing instance
cloc.update(ad, length, false);			// feed AD by chunks
cloc.update(ad, length, true); 			// feed last AD chunk
cloc.nonce(nonce, length);				// apply noce
cloc.encrypt(out, datachunk, false);	// feed data by chunks
cloc.encrypt(out, lastdatachunk, true);	// feed last data chunk

// MAC
var mac = new ChaskeyCipher.Mac();	// instantiate a cipher in MAC mode
mac.set(key);						// set the key
var cif = mac.sign(message);		// sign the message

// CBC
var cbc = new ChaskeyCipher.Cbc();	// instantiate a cipher in CBC mode
cbc.set(key);						// set the key
cbc.init(nonce);					// init  cipher with a nonce
var cif = cbc.encrypt(message);		// encrypt the message

Table below lists benchmarking results for 1M operations on a 32-bytes-long message.

Values are give in ms, All binaries were compiled with gcc option -O3 -- Optimize most.
^*NodeMCU, MSP430 and Arduino Mega results are extrapolated from tests with 100K operations

Next table shows same results in normilized form - clock cycles per one operation

State size, including the key, dervied keys and formatter's buffer, bytes: