HC-128
Documentation |
#include <cryptopp/hc128.h>
|
HC-128 and HC-256 are stream ciphers by Hongjun Wu. The ciphers use a 128-bit key, and a 128-bit initialization vector (IV). The ciphers are part of eSTREAM portfolio Phase 3 (final) for Profile 1 (software). The reference materials and source files used for the Crypto++ implementation are available at The eSTREAM Project | HC-128 and The eSTREAM Project | HC-256.
Crypto++ provides all stream ciphers from eSTREAM Phase 3 for Profile 1. The ciphers are ChaCha, HC-128/256, Rabbit, Salsa20 and Sosemanuk. The IETF's version of ChaCha is specified in RFC 7539, ChaCha20 and Poly1305 for IETF Protocols and available as ChaChaTLS.
If you are used to working in languages like Java or libraries like OpenSSL, then you might want to visit the Init-Update-Final wiki page. Crypto++ provides the transformation model, but its not obvious because its often shrouded behind Pipelines.
Note: if your project is using encryption alone to secure your data, encryption alone is usually not enough. Please take a moment to read Authenticated Encryption and consider using an algorithm or mode like CCM, GCM, EAX or ChaCha20Poly1305.
Key and IV sizes
The first sample program prints HC-128's key and iv sizes.
int main() { using namespace CryptoPP; HC128::Encryption enc; std::cout << "key length: " << enc.DefaultKeyLength() << std::endl; std::cout << "key length (min): " << enc.MinKeyLength () << std::endl; std::cout << "key length (max): " << enc.MaxKeyLength () << std::endl; std::cout << "iv size: " << enc.IVSize() << std::endl; return 0; }
A typical output is shown below.
$ ./test.exe key length: 16 key length (min): 16 key length (max): 16 iv size: 16
Switching to HC256
results in the following.
$ ./test.exe key length: 32 key length (min): 32 key length (max): 32 iv size: 32
Encryption and Decryption
The following example shows you how to use HC128::Encryption
and HC128::Decryption
. &cipher[0]
may look odd, but its how to get the non-const pointer from a std::string
.
#include "cryptlib.h" #include "secblock.h" #include "filters.h" #include "hc128.h" #include "osrng.h" #include "files.h" #include "hex.h" #include <iostream> #include <string> int main() { using namespace CryptoPP; AutoSeededRandomPool prng; HexEncoder encoder(new FileSink(std::cout)); std::string plain("HC-128 stream cipher test"), cipher, recover; SecByteBlock key(16), iv(16); prng.GenerateBlock(key, key.size()); prng.GenerateBlock(iv, iv.size()); std::cout << "Key: "; encoder.Put(key.data(), key.size()); encoder.MessageEnd(); std::cout << std::endl; std::cout << "IV: "; encoder.Put(iv.data(), iv.size()); encoder.MessageEnd(); std::cout << std::endl; // Encryption object HC128::Encryption enc; enc.SetKeyWithIV(key, key.size(), iv, iv.size()); // Decryption object HC128::Decryption dec; dec.SetKeyWithIV(key, key.size(), iv, iv.size()); StringSource ss1(plain, true, new StreamTransformationFilter(enc, new StringSink(cipher))); StringSource ss2(cipher, true, new StreamTransformationFilter(dec, new StringSink(recover))); std::cout << "Plain: " << plain << std::endl; std::cout << "Cipher: "; encoder.Put((const byte*)cipher.data(), cipher.size()); encoder.MessageEnd(); std::cout << std::endl; std::cout << "Recovered: " << recover << std::endl; return 0; }
A typical output is shown below.
$ ./test.exe Key: A51C983C4FED6368A46236AF1163D91F IV: 79F6704906ED2DD9607F46FFC0932CED Plain: HC-128 stream cipher test Cipher: D19BB4B0078CDB27861655E742117432A65563636770E1C784 Recovered: HC-128 stream cipher test
Resynchronizing
The HC-128 and HC-256 ciphers are self-inverting so you can use the encryption object for decryption (and vice versa). The cipher holds internal state and is resynchronizable. If you want to reuse an encryption or decryption object then you should set the IV with Resynchronize
.
#include "cryptlib.h" #include "secblock.h" #include "hc128.h" #include "osrng.h" #include "files.h" #include "hex.h" #include <iostream> #include <string> int main() { using namespace CryptoPP; AutoSeededRandomPool prng; HexEncoder encoder(new FileSink(std::cout)); std::string plain("HC-128 stream cipher test"), cipher, recover; SecByteBlock key(16), iv(16); prng.GenerateBlock(key, key.size()); prng.GenerateBlock(iv, iv.size()); std::cout << "Key: "; encoder.Put((const byte*)key.data(), key.size()); encoder.MessageEnd(); std::cout << std::endl; std::cout << "IV: "; encoder.Put((const byte*)iv.data(), iv.size()); encoder.MessageEnd(); std::cout << std::endl; // Encryption object HC128::Encryption enc; enc.SetKeyWithIV(key, key.size(), iv, iv.size()); // Perform the encryption cipher.resize(plain.size()); enc.ProcessData((byte*)&cipher[0], (const byte*)plain.data(), plain.size()); std::cout << "Plain: " << plain << std::endl; std::cout << "Cipher: "; encoder.Put((const byte*)cipher.data(), cipher.size()); encoder.MessageEnd(); std::cout << std::endl; // HC128::Decryption dec; // dec.SetKeyWithIV(key, key.size(), iv, iv.size()); std::cout << "Self inverting: " << enc.IsSelfInverting() << std::endl; std::cout << "Resynchronizable: " << enc.IsResynchronizable() << std::endl; enc.Resynchronize(iv, iv.size()); // Perform the decryption // recover.resize(cipher.size()); // dec.ProcessData((byte*)&recover[0], (const byte*)cipher.data(), cipher.size()); // Perform the decryption with the encryptor recover.resize(cipher.size()); enc.ProcessData((byte*)&recover[0], (const byte*)cipher.data(), cipher.size()); std::cout << "Recovered: " << recover << std::endl; return 0; }
A typical output is shown below.
$ ./test.exe Key: 16A6B0B6BB1D66D23CBB64B97DA7A248 IV: 27133B6F8840B49F2A146CE27D9E4B01 Plain: HC-128 stream cipher test Cipher: 3DF61A1929893CA90D1762004B100DE7A2F35567D090172E8B Self inverting: 1 Resynchronizable: 1 Recovered: HC-128 stream cipher test
The following C++11 program demonstrates resynchronizing without the additional operations like printing a key or iv. The library was built with CXXFLAGS="-DNDEBUG -g2 -O3 -std=c++11
.
#include "cryptlib.h" #include "hc128.h" #include <iostream> #include <array> #include <cstdint> int main(int argc, char *argv[]) { using namespace CryptoPP; const uint8_t hc128Key[16] = "012345678901234"; const uint8_t hc128IV[16] = "0123456789101234"; HC128::Encryption enc; HC128::Decryption dec; enc.SetKeyWithIV(hc128Key, 16, hc128IV, 16); dec.SetKeyWithIV(hc128Key, 16, hc128IV, 16); std::array<byte, 3> origin = { 1,2,3 }; std::array<byte, 3> encrpyt; enc.ProcessData(encrpyt.data(), origin.data(), origin.size()); std::array<byte, 3> decrypt; dec.ProcessData(decrypt.data(), encrpyt.data(), encrpyt.size()); dec.Resynchronize(hc128IV, sizeof(hc128IV)); dec.ProcessData(decrypt.data(), encrpyt.data(), encrpyt.size()); dec.Resynchronize(hc128IV, sizeof(hc128IV)); dec.ProcessData(decrypt.data(), encrpyt.data(), encrpyt.size()); std::cout << (int)decrypt[0] << " " << (int)decrypt[1] << " "; std::cout << (int)decrypt[2] << std::endl; return 0; }
It produces the following result.
$ g++ -DNDEBUG -g2 -O3 -std=c++11 test.cxx -o test.exe ./libcryptopp.a $ ./test.exe 1 2 3
HC-256
Switching to HC-256 is as easy as swapping in a HC256
object and including hc256.h
.
#include "cryptlib.h" #include "secblock.h" #include "filters.h" #include "hc256.h" #include "osrng.h" #include "files.h" #include "hex.h" #include <iostream> #include <string> int main() { using namespace CryptoPP; AutoSeededRandomPool prng; HexEncoder encoder(new FileSink(std::cout)); std::string plain("HC-256 stream cipher test"), cipher, recover; SecByteBlock key(32), iv(32); prng.GenerateBlock(key, key.size()); prng.GenerateBlock(iv, iv.size()); std::cout << "Key: "; encoder.Put(key.data(), key.size()); encoder.MessageEnd(); std::cout << std::endl; std::cout << "IV: "; encoder.Put(iv.data(), iv.size()); encoder.MessageEnd(); std::cout << std::endl; // Encryption object HC256::Encryption enc; enc.SetKeyWithIV(key, key.size(), iv, iv.size()); // Decryption object HC256::Decryption dec; dec.SetKeyWithIV(key, key.size(), iv, iv.size()); StringSource ss1(plain, true, new StreamTransformationFilter(enc, new StringSink(cipher))); StringSource ss2(cipher, true, new StreamTransformationFilter(dec, new StringSink(recover))); std::cout << "Plain: " << plain << std::endl; std::cout << "Cipher: "; encoder.Put((const byte*)cipher.data(), cipher.size()); encoder.MessageEnd(); std::cout << std::endl; std::cout << "Recovered: " << recover << std::endl; return 0; }
A typical output is shown below.
$ ./test.exe Key: CBCBA550FE1A5C34E0C4D6A14D056A08032EA11CF700BD7B9D409B68DC47B9B7 IV: 2E58581CFD129ACE30BD1F86739C713A867550A3DD6D9E0886F63C01B6F9531F Plain: HC-256 stream cipher test Cipher: 957BD81955B68A34A4C151D73F89E837945C364CE5B2942CC2 Recovered: HC-256 stream cipher test
Pipelines
You can also use stream ciphers in a Pipeline. Below is an example of HC-128 participating in a pipeline. Internally, StreamTransformationFilter
calls ProcessData
on the incoming data stream. The filter also buffers output if there is no attached transformation or sink.
#include "cryptlib.h" #include "secblock.h" #include "filters.h" #include "hc128.h" #include "osrng.h" #include "files.h" #include "hex.h" #include <iostream> #include <string> int main() { using namespace CryptoPP; AutoSeededRandomPool prng; HexEncoder encoder(new FileSink(std::cout)); std::string plain("HC-128 stream cipher test"), cipher, recover; SecByteBlock key(16), iv(16); prng.GenerateBlock(key, key.size()); prng.GenerateBlock(iv, iv.size()); std::cout << "Key: "; encoder.Put(key.data(), key.size()); encoder.MessageEnd(); std::cout << std::endl; std::cout << "IV: "; encoder.Put(iv.data(), iv.size()); encoder.MessageEnd(); std::cout << std::endl; // Encryption object HC128::Encryption enc; enc.SetKeyWithIV(key, key.size(), iv, iv.size()); // Decryption object HC128::Decryption dec; dec.SetKeyWithIV(key, key.size(), iv, iv.size()); StringSource ss1(plain, true, new StreamTransformationFilter(enc, new StringSink(cipher))); StringSource ss2(cipher, true, new StreamTransformationFilter(dec, new StringSink(recover))); std::cout << "Plain: " << plain << std::endl; std::cout << "Cipher: "; encoder.Put((const byte*)cipher.data(), cipher.size()); encoder.MessageEnd(); std::cout << std::endl; std::cout << "Recovered: " << recover << std::endl; return 0; }
The program produces the expected output:
$ ./test.exe Key: E9F2DFA067F1805A466D21A3617E1A81 IV: FCC07AFEC1B829A9B51B49BE0C3C59B7 Plain: HC-128 stream cipher test Cipher: 811A4A9C1EBB223D3DF0AA0B3C518114D68490A5B120A9FA9C Recovered: HC-128 stream cipher test