ARIA
| Documentation |
#include <cryptopp/aria.h>
|
ARIA is a 128-bit block cipher created by Daesung Kwon, Jaesung Kim, Sangwoo Park, Soo Hak Sung, Yaekwon Sohn, Jung Hwan Song, Yongjin Yeom, E-Joong Yoon, Sangjin Lee, Jaewon Lee, Seongtaek Chee, Daewan Han, and Jin Hong. The algorithm provides 128, 192 and 256-bit key sizes. The ARIA homepage is located at Korea Internet & Security Agency.
Crypto++ offers several ciphers from Korea Internet & Security Agency portfolio. The algorithms include ARIA, HIGHT, LEA, LSH and SEED. Additionally the library offers CHAM.
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.
Sample Programs
There are three sample programs. The first shows ARIA key and block sizes. The second and third use filters in a pipeline. Pipelining is a high level abstraction and it handles buffering input, buffering output and padding for you.
If you are benchmarking then you may want to visit Benchmarks | Sample Program . It shows you how to use StreamTransformation::ProcessString method to process multiple blocks at a time using a standard C++ interface. Calling a cipher's ProcessString or ProcessBlock eventually call a cipher's ProcessAndXorBlock or AdvancedProcessBlocks, and they are the lowest level API you can use.
The first example dumps the minimum, maximum, and default key lengths used by ARIA.
using namespace CryptoPP;
int main(int argc, char* argv[])
{
std::cout << "key length: " << ARIA::DEFAULT_KEYLENGTH << std::endl;
std::cout << "key length (min): " << ARIA::MIN_KEYLENGTH << std::endl;
std::cout << "key length (max): " << ARIA::MAX_KEYLENGTH << std::endl;
std::cout << "block size: " << ARIA::BLOCKSIZE << std::endl;
return 0;
}
Output from the above snippet produces the following. Notice the default key size is 128 bits or 16 bytes.
key length: 16 key length (min): 16 key length (max): 32 block size: 16
The following program shows how to operate ARIA in CBC mode using a pipeline. The key is declared on the stack using a SecByteBlock to ensure the sensitive material is zeroized. Similar could be used for both plain text and recovered text.
using namespace CryptoPP;
void Print(const std::string& label, const std::string& val)
{
std::string encoded;
StringSource(val, true,
new HexEncoder(
new StringSink(encoded)
) // HexEncoder
); // StringSource
std::cout << label << ": " << encoded << std::endl;
}
int main(int argc, char* argv[])
{
AutoSeededRandomPool prng;
SecByteBlock key(ARIA::DEFAULT_KEYLENGTH);
SecByteBlock iv(ARIA::BLOCKSIZE);
prng.GenerateBlock(key, key.size());
prng.GenerateBlock(iv, iv.size());
std::string plain = "CBC Mode Test";
std::string cipher, encoded, recovered;
/*********************************\
\*********************************/
try
{
std::cout << "plain text: " << plain << std::endl;
CBC_Mode< ARIA >::Encryption e;
e.SetKeyWithIV(key, key.size(), iv);
// The StreamTransformationFilter adds padding
// as required. ECB and CBC Mode must be padded
// to the block size of the cipher.
StringSource s(plain, true,
new StreamTransformationFilter(e,
new StringSink(cipher)
) // StreamTransformationFilter
); // StringSource
}
catch(const CryptoPP::Exception& e)
{
std::cerr << e.what() << std::endl;
exit(1);
}
/*********************************\
\*********************************/
Print("key", std::string((const char*)key.begin(), key.size()));
Print("iv", std::string((const char*)iv.begin(), iv.size()));
Print("cipher text", cipher);
/*********************************\
\*********************************/
try
{
CBC_Mode< ARIA >::Decryption d;
d.SetKeyWithIV(key, key.size(), iv);
// The StreamTransformationFilter removes
// padding as required.
StringSource s(cipher, true,
new StreamTransformationFilter(d,
new StringSink(recovered)
) // StreamTransformationFilter
); // StringSource
std::cout << "recovered text: " << recovered << std::endl;
}
catch(const CryptoPP::Exception& e)
{
std::cerr << e.what() << std::endl;
exit(1);
}
return 0;
}
A typical output is shown below. Note that each run will produce different results because the key and initialization vector are randomly generated.
$ ./test.exe plain text: CBC Mode Test key: 1A9A4163B68325E4AA51C3641764FC16 iv: EB0E00ABECE3F40E7D51E5E2B10FC1C6 cipher text: 54994759AA6CC22D8963E89EA4CABEED recovered text: CBC Mode Test
The third program modifies the second program by switching to EAX mode. Authenticity assurances can placed on the cipher text for nearly no programming costs by using an authenticated encryption mode. Below the StreamTransformationFilter was replaced by AuthenticatedEncryptionFilter and AuthenticatedDecryptionFilter.
EAX< ARIA >::Encryption e;
e.SetKeyWithIV(key, key.size(), iv);
StringSource(plain, true,
new AuthenticatedEncryptionFilter(e,
new StringSink(cipher)
) // StreamTransformationFilter
); // StringSource
...
EAX< ARIA >::Decryption d;
d.SetKeyWithIV(key, key.size(), iv);
StringSource s(cipher, true,
new AuthenticatedDecryptionFilter(d,
new StringSink(recovered)
) // StreamTransformationFilter
); // StringSource
Typical output is as follows. Notice the additional cipher text bytes due to the MAC bytes. See EAX Mode for details.
$ ./test.exe plain text: EAX Mode Test key: 8EE5446F062D410EACF03D7C7E3C303A iv: 086A4765E1A0E8E575D68C5EC241E750 cipher text: 270EA92039C466B53E2C932FE82EDD45865583E20DFCE10D66D630E023 recovered text: EAX Mode Test
To manually insert bytes into the filter, perform multiple Puts. Though Get is used below, a StringSink could easily be attached and save the administrivia.
const size_t SIZE = 16 * 4;
string plain(SIZE, 0x00);
for(size_t i = 0; i < plain.size(); i++)
plain[i] = 'A' + (i%26);
...
CBC_Mode < ARIA >::Encryption encryption(key, sizeof(key), iv);
StreamTransformationFilter encryptor(encryption, NULL);
for(size_t j = 0; j < plain.size(); j++)
encryptor.Put((byte)plain[j]);
encryptor.MessageEnd();
size_t ready = encryptor.MaxRetrievable();
string cipher(ready, 0x00);
encryptor.Get((byte*) &cipher[0], cipher.size());
Downloads
No downloads.