virgil-crypto 2.0.2b0

data/ext/native/src/tests/test_runner.cxx

@@ -0,0 +1,43 @@
+/**
+ * Copyright (C) 2015-2016 Virgil Security Inc.
+ *
+ * Lead Maintainer: Virgil Security Inc. <support@virgilsecurity.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     (1) Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *     (2) Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *
+ *     (3) Neither the name of the copyright holder nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file test_runner.cxx
+ * @brief Tests entrypoint
+ */
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"

data/ext/native/src/tests/test_signer.cxx

@@ -0,0 +1,111 @@
+/**
+ * Copyright (C) 2015-2016 Virgil Security Inc.
+ *
+ * Lead Maintainer: Virgil Security Inc. <support@virgilsecurity.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     (1) Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *     (2) Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *
+ *     (3) Neither the name of the copyright holder nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file test_signer.cxx
+ * @brief Covers class VirgilSigner
+ */
+
+#include "catch.hpp"
+
+#include <virgil/crypto/VirgilByteArray.h>
+#include <virgil/crypto/VirgilSigner.h>
+#include <virgil/crypto/VirgilKeyPair.h>
+#include <virgil/crypto/VirgilCryptoException.h>
+
+using virgil::crypto::str2bytes;
+using virgil::crypto::VirgilByteArray;
+using virgil::crypto::VirgilSigner;
+using virgil::crypto::VirgilKeyPair;
+using virgil::crypto::VirgilCryptoException;
+
+static void test_sign_verify(const VirgilKeyPair& keyPair, const VirgilByteArray& keyPassword = VirgilByteArray()) {
+    VirgilByteArray testData = str2bytes("this string will be signed");
+    VirgilByteArray malformedData = str2bytes("this string will is malformed");
+    VirgilByteArray malformedSign = str2bytes("I am malformed sign");
+
+    VirgilSigner signer;
+    VirgilByteArray sign = signer.sign(testData, keyPair.privateKey(), keyPassword);
+
+    SECTION("and verify with original data and correspond sign") {
+        REQUIRE(signer.verify(testData, sign, keyPair.publicKey()));
+    }
+
+    SECTION("and verify with malformed data") {
+        REQUIRE(!signer.verify(malformedData, sign, keyPair.publicKey()));
+    }
+
+    SECTION("and verify with malformed sign") {
+        REQUIRE_THROWS_AS(signer.verify(testData, malformedSign, keyPair.publicKey()), VirgilCryptoException);
+    }
+}
+
+#define TEST_CASE_SIGN_VERIFY(KeyType) \
+    TEST_CASE("VirgilSigner: " #KeyType, "[signer]") { \
+        test_sign_verify(VirgilKeyPair::generate(VirgilKeyPair::Type::KeyType)); \
+    }
+
+TEST_CASE_SIGN_VERIFY(RSA_2048)
+
+TEST_CASE_SIGN_VERIFY(EC_BP384R1)
+
+TEST_CASE_SIGN_VERIFY(EC_SECP256K1)
+
+TEST_CASE_SIGN_VERIFY(EC_SECP256R1)
+
+TEST_CASE_SIGN_VERIFY(EC_CURVE25519)
+
+TEST_CASE_SIGN_VERIFY(FAST_EC_ED25519)
+
+#undef TEST_CASE_SIGN_VERIFY
+
+TEST_CASE("VirgilSigner: RSA with small key", "[signer]") {
+    VirgilByteArray testData = str2bytes("this string will be signed");
+    VirgilByteArray keyPassword = str2bytes("password");
+    VirgilKeyPair keyPair = VirgilKeyPair::generate(VirgilKeyPair::Type::RSA_256, keyPassword);
+
+    REQUIRE_THROWS(VirgilSigner().sign(testData, keyPair.privateKey(), keyPassword));
+}
+
+TEST_CASE("VirgilSigner: sign with wrong key password", "[signer]") {
+    VirgilByteArray testData = str2bytes("this string will be signed");
+    VirgilByteArray keyPassword = str2bytes("password");
+    VirgilByteArray wrongKeyPassword = str2bytes("wrong password");
+    VirgilKeyPair keyPair = VirgilKeyPair::generate(VirgilKeyPair::Type::FAST_EC_X25519, keyPassword);
+
+    VirgilSigner signer;
+    REQUIRE_THROWS_AS(signer.sign(testData, keyPair.privateKey(), wrongKeyPassword), VirgilCryptoException);
+}

data/ext/native/src/tests/test_stream_cipher.cxx

@@ -0,0 +1,277 @@
+/**
+ * Copyright (C) 2015-2016 Virgil Security Inc.
+ *
+ * Lead Maintainer: Virgil Security Inc. <support@virgilsecurity.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     (1) Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *     (2) Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *
+ *     (3) Neither the name of the copyright holder nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file test_stream_cipher.cxx
+ * @brief Covers class VirgilStreamCipher
+ */
+
+#if LIB_FILE_IO
+
+#include "catch.hpp"
+
+#include <virgil/crypto/VirgilByteArray.h>
+#include <virgil/crypto/VirgilStreamCipher.h>
+#include <virgil/crypto/VirgilKeyPair.h>
+#include <virgil/crypto/stream/VirgilBytesDataSource.h>
+#include <virgil/crypto/stream/VirgilBytesDataSink.h>
+
+using virgil::crypto::str2bytes;
+using virgil::crypto::bytes2hex;
+using virgil::crypto::VirgilByteArray;
+using virgil::crypto::VirgilStreamCipher;
+using virgil::crypto::VirgilKeyPair;
+using virgil::crypto::stream::VirgilBytesDataSource;
+using virgil::crypto::stream::VirgilBytesDataSink;
+
+TEST_CASE("Stream Cipher: encrypt and decrypt with generated keys", "[stream-cipher]") {
+    VirgilByteArray password = str2bytes("password");
+    VirgilByteArray recipientId = str2bytes("2e8176ba-34db-4c65-b977-c5eac687c4ac");
+    VirgilKeyPair keyPair = VirgilKeyPair::generateRecommended(password);
+
+    VirgilByteArray testData = str2bytes("this string will be encrypted");
+    VirgilBytesDataSource testDataSource(testData);
+
+    VirgilByteArray encryptedData;
+    VirgilBytesDataSink encryptedDataSink(encryptedData);
+    VirgilBytesDataSource encryptedDataSource(encryptedData);
+
+    VirgilByteArray decryptedData;
+    VirgilBytesDataSink decryptedDataSink(decryptedData);
+
+    VirgilStreamCipher encCipher;
+    VirgilStreamCipher decCipher;
+    encCipher.addKeyRecipient(recipientId, keyPair.publicKey());
+
+    SECTION("and embedded content info") {
+        testDataSource.reset();
+        encryptedDataSource.reset();
+        decryptedDataSink.reset();
+
+        encCipher.encrypt(testDataSource, encryptedDataSink, true);
+
+        encryptedDataSource.reset();
+        decryptedDataSink.reset();
+        REQUIRE_THROWS(
+            decCipher.decryptWithKey(encryptedDataSource, decryptedDataSink, recipientId, keyPair.privateKey())
+        );
+        encryptedDataSource.reset();
+        decryptedDataSink.reset();
+        REQUIRE_NOTHROW(
+            decCipher.decryptWithKey(encryptedDataSource, decryptedDataSink, recipientId, keyPair.privateKey(), password)
+        );
+        REQUIRE(testData == decryptedData);
+    }
+
+    SECTION("and embedded content info with custom parameters") {
+        VirgilByteArray intParamKey = str2bytes("int_parameter_key");
+        const int intParamValue = 35777;
+        VirgilByteArray strParamKey = str2bytes("string_parameter_key");
+        VirgilByteArray strParamValue = str2bytes("string parameter");
+        VirgilByteArray hexParamKey = str2bytes("data_param_value");
+        VirgilByteArray hexParamValue = str2bytes("will be stored as octet string");
+
+        encCipher.customParams().setInteger(intParamKey, intParamValue);
+        encCipher.customParams().setString(strParamKey, strParamValue);
+        encCipher.customParams().setData(hexParamKey, hexParamValue);
+
+        testDataSource.reset();
+        encryptedDataSource.reset();
+        decryptedDataSink.reset();
+
+        encCipher.encrypt(testDataSource, encryptedDataSink, true);
+        encCipher.removeAllRecipients();
+        encCipher.customParams().clear();
+
+        encryptedDataSource.reset();
+        decryptedDataSink.reset();
+        REQUIRE_NOTHROW(
+            decCipher.decryptWithKey(encryptedDataSource, decryptedDataSink, recipientId, keyPair.privateKey(), password)
+        );
+        REQUIRE(testData == decryptedData);
+
+        REQUIRE(decCipher.customParams().getInteger(intParamKey) == intParamValue);
+        REQUIRE(decCipher.customParams().getString(strParamKey) == strParamValue);
+        REQUIRE(decCipher.customParams().getData(hexParamKey) == hexParamValue);
+    }
+
+    SECTION("and separated content info") {
+        testDataSource.reset();
+        encryptedDataSource.reset();
+        decryptedDataSink.reset();
+
+        encCipher.encrypt(testDataSource, encryptedDataSink, false);
+        VirgilByteArray contentInfo = encCipher.getContentInfo();
+        REQUIRE(contentInfo.size() > 0);
+        encCipher.removeAllRecipients();
+        encCipher.customParams().clear();
+
+        REQUIRE_NOTHROW(
+            decCipher.setContentInfo(contentInfo)
+        );
+        encryptedDataSource.reset();
+        decryptedDataSink.reset();
+        REQUIRE_THROWS(
+            decCipher.decryptWithKey(encryptedDataSource, decryptedDataSink, recipientId, keyPair.privateKey())
+        );
+        encryptedDataSource.reset();
+        decryptedDataSink.reset();
+        REQUIRE_NOTHROW(
+            decCipher.decryptWithKey(encryptedDataSource, decryptedDataSink, recipientId, keyPair.privateKey(), password)
+        );
+        REQUIRE(testData == decryptedData);
+    }
+
+    SECTION("and separated content info with custom parameters") {
+        VirgilByteArray intParamKey = str2bytes("int_parameter_key");
+        const int intParamValue = 35777;
+        VirgilByteArray strParamKey = str2bytes("string_parameter_key");
+        VirgilByteArray strParamValue = str2bytes("string parameter");
+        VirgilByteArray hexParamKey = str2bytes("data_param_value");
+        VirgilByteArray hexParamValue = str2bytes("will be stored as octet string");
+
+        encCipher.customParams().setInteger(intParamKey, intParamValue);
+        encCipher.customParams().setString(strParamKey, strParamValue);
+        encCipher.customParams().setData(hexParamKey, hexParamValue);
+
+        testDataSource.reset();
+        encryptedDataSource.reset();
+        decryptedDataSink.reset();
+
+        encCipher.encrypt(testDataSource, encryptedDataSink, false);
+        VirgilByteArray contentInfo = encCipher.getContentInfo();
+        encCipher.removeAllRecipients();
+        encCipher.customParams().clear();
+
+        REQUIRE_NOTHROW(
+            decCipher.setContentInfo(contentInfo)
+        );
+
+        encryptedDataSource.reset();
+        decryptedDataSink.reset();
+        REQUIRE_NOTHROW(
+            decCipher.decryptWithKey(encryptedDataSource, decryptedDataSink, recipientId, keyPair.privateKey(), password)
+        );
+        REQUIRE(testData == decryptedData);
+
+        REQUIRE(decCipher.customParams().getInteger(intParamKey) == intParamValue);
+        REQUIRE(decCipher.customParams().getString(strParamKey) == strParamValue);
+        REQUIRE(decCipher.customParams().getData(hexParamKey) == hexParamValue);
+    }
+}
+
+TEST_CASE("Stream Cipher: generated keys", "[stream-cipher]") {
+    VirgilByteArray testData = str2bytes("this string will be encrypted");
+    VirgilByteArray bobId = str2bytes("2e8176ba-34db-4c65-b977-c5eac687c4ac");
+    VirgilByteArray johnId = str2bytes("968dc52d-2045-4abe-ab51-0b04737cac76");
+    VirgilKeyPair bobKeyPair = VirgilKeyPair::generateRecommended();
+    VirgilKeyPair johnKeyPair = VirgilKeyPair::generateRecommended();
+    VirgilByteArray alicePassword = str2bytes("alice secret");
+
+    VirgilBytesDataSource testDataSource(testData);
+
+    VirgilByteArray encryptedData;
+    VirgilBytesDataSink encryptedDataSink(encryptedData);
+    VirgilBytesDataSource encryptedDataSource(encryptedData);
+
+    VirgilByteArray decryptedData;
+    VirgilBytesDataSink decryptedDataSink(decryptedData);
+
+    VirgilStreamCipher encCipher;
+    VirgilStreamCipher decCipher;
+    encCipher.addKeyRecipient(bobId, bobKeyPair.publicKey());
+    encCipher.addKeyRecipient(johnId, johnKeyPair.publicKey());
+    encCipher.addPasswordRecipient(alicePassword);
+
+    SECTION("encrypt for multiple recipients with embedded content info") {
+        encCipher.encrypt(testDataSource, encryptedDataSink, true);
+        encCipher.removeAllRecipients();
+
+        SECTION("decrypt for Bob") {
+            encryptedDataSource.reset();
+            decCipher.decryptWithKey(encryptedDataSource, decryptedDataSink, bobId, bobKeyPair.privateKey());
+            REQUIRE(testData == decryptedData);
+        }
+
+        SECTION("decrypt for John") {
+            encryptedDataSource.reset();
+            decCipher.decryptWithKey(encryptedDataSource, decryptedDataSink, johnId, johnKeyPair.privateKey());
+            REQUIRE(testData == decryptedData);
+        }
+
+        SECTION("decrypt for Alice") {
+            encryptedDataSource.reset();
+            decCipher.decryptWithPassword(encryptedDataSource, decryptedDataSink, alicePassword);
+            REQUIRE(testData == decryptedData);
+        }
+    }
+
+    SECTION("encrypt for multiple recipients with separated content info") {
+        encCipher.encrypt(testDataSource, encryptedDataSink, false);
+        VirgilByteArray contentInfo = encCipher.getContentInfo();
+        encCipher.removeAllRecipients();
+
+        REQUIRE_NOTHROW(
+            decCipher.setContentInfo(contentInfo)
+        );
+
+        SECTION("decrypt for Bob") {
+            encryptedDataSource.reset();
+            decCipher.decryptWithKey(encryptedDataSource, decryptedDataSink, bobId, bobKeyPair.privateKey());
+            REQUIRE(testData == decryptedData);
+        }
+
+        SECTION("decrypt for John") {
+            encryptedDataSource.reset();
+            decCipher.decryptWithKey(encryptedDataSource, decryptedDataSink, johnId, johnKeyPair.privateKey());
+            REQUIRE(testData == decryptedData);
+        }
+
+        SECTION("decrypt for Alice") {
+            encryptedDataSource.reset();
+            decCipher.decryptWithPassword(encryptedDataSource, decryptedDataSink, alicePassword);
+            REQUIRE(testData == decryptedData);
+        }
+    }
+}
+
+#else
+#if defined(_MSC_VER)
+#pragma message("Tests for class VirgilStreamCipher are ignored, because LIB_FILE_IO build parameter is not defined")
+#else
+#warning "Tests for class VirgilStreamCipher are ignored, because LIB_FILE_IO build parameter is not defined"
+#endif /* _MSC_VER */
+#endif /* LIB_FILE_IO */

data/ext/native/src/tests/test_symmetric_cipher.cxx

@@ -0,0 +1,105 @@
+/**
+ * Copyright (C) 2015-2016 Virgil Security Inc.
+ *
+ * Lead Maintainer: Virgil Security Inc. <support@virgilsecurity.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     (1) Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *     (2) Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *
+ *     (3) Neither the name of the copyright holder nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file test_symmetric_cipher.cxx
+ * @brief Covers class VirgilSymmetricCipher
+ */
+
+#include "catch.hpp"
+
+#include <virgil/crypto/VirgilByteArray.h>
+#include <virgil/crypto/foundation/VirgilSymmetricCipher.h>
+#include <virgil/crypto/foundation/VirgilRandom.h>
+
+using virgil::crypto::str2bytes;
+using virgil::crypto::hex2bytes;
+using virgil::crypto::bytes2str;
+using virgil::crypto::bytes2hex;
+using virgil::crypto::VirgilByteArray;
+using virgil::crypto::foundation::VirgilSymmetricCipher;
+using virgil::crypto::foundation::VirgilRandom;
+
+TEST_CASE("Symmetric Cipher", "[symmetric-cipher]") {
+    VirgilSymmetricCipher cipher(VirgilSymmetricCipher::Algorithm::AES_256_GCM);
+    VirgilByteArray plainData = str2bytes("data to be encrypted with symmetric cipher");
+
+    SECTION("with known KEY and IV") {
+        // Init keys
+        VirgilByteArray key = hex2bytes("194122b1bee2f8c25ea5e0f02b1a3376d3a3dd1252365a2acefabead3cf6ab4c");
+        VirgilByteArray iv = hex2bytes("fb0a9fc004041e7d95b7555d282f0bd653d6d688fd6f5be26863115a7c1254e0");
+        key.resize(cipher.keyLength());
+        iv.resize(cipher.ivSize());
+        // Encrypt
+        cipher.setEncryptionKey(key);
+        if (cipher.isSupportPadding()) {
+            cipher.setPadding(VirgilSymmetricCipher::Padding::PKCS7);
+        }
+        VirgilByteArray encryptedData = cipher.crypt(plainData, iv);
+        // Decrypt
+        cipher.clear();
+        cipher.setDecryptionKey(key);
+        if (cipher.isSupportPadding()) {
+            cipher.setPadding(VirgilSymmetricCipher::Padding::PKCS7);
+        }
+        VirgilByteArray decryptedData = cipher.crypt(encryptedData, iv);
+        // Check
+        REQUIRE(bytes2str(plainData) == bytes2str(decryptedData));
+    }
+
+    SECTION("with random KEY and IV") {
+        // Init randomizer
+        VirgilRandom random(str2bytes("test_symmetric_cipher"));
+        // Init keys
+        VirgilByteArray key = random.randomize(cipher.keyLength());
+        VirgilByteArray iv = random.randomize(cipher.ivSize());
+        // Encrypt
+        cipher.setEncryptionKey(key);
+        if (cipher.isSupportPadding()) {
+            cipher.setPadding(VirgilSymmetricCipher::Padding::PKCS7);
+        }
+        VirgilByteArray encryptedData = cipher.crypt(plainData, iv);
+        // Decrypt
+        cipher.clear();
+        cipher.setDecryptionKey(key);
+        if (cipher.isSupportPadding()) {
+            cipher.setPadding(VirgilSymmetricCipher::Padding::PKCS7);
+        }
+        VirgilByteArray decryptedData = cipher.crypt(encryptedData, iv);
+        // Check
+        REQUIRE(bytes2str(plainData) == bytes2str(decryptedData));
+    }
+}