virgil-crypto 2.0.2b0

data/ext/native/src/lib/src/VirgilCMSEncryptedContent.cxx

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ */
+
+#include <virgil/crypto/foundation/cms/VirgilCMSEncryptedContent.h>
+
+#include <virgil/crypto/VirgilCryptoException.h>
+#include <virgil/crypto/foundation/internal/VirgilOID.h>
+#include <virgil/crypto/foundation/asn1/VirgilAsn1Reader.h>
+#include <virgil/crypto/foundation/asn1/VirgilAsn1Writer.h>
+
+#include <virgil/crypto/internal/utils.h>
+
+using virgil::crypto::VirgilCryptoException;
+using virgil::crypto::foundation::cms::VirgilCMSEncryptedContent;
+using virgil::crypto::foundation::asn1::VirgilAsn1Reader;
+using virgil::crypto::foundation::asn1::VirgilAsn1Writer;
+
+/**
+ * @name ASN.1 Constants for CMS
+ */
+///@{
+static const unsigned char kCMS_EncryptedContentTag = 0;
+///@}
+
+size_t VirgilCMSEncryptedContent::asn1Write(VirgilAsn1Writer& asn1Writer, size_t childWrittenBytes) const {
+    size_t len = 0;
+    if (!encryptedContent.empty()) {
+        size_t encryptedContentLen = asn1Writer.writeOctetString(encryptedContent);
+        len += encryptedContentLen;
+        len += asn1Writer.writeContextTag(kCMS_EncryptedContentTag, encryptedContentLen);
+    }
+
+    checkRequiredField(contentEncryptionAlgorithm);
+    len += asn1Writer.writeData(contentEncryptionAlgorithm);
+
+    len += asn1Writer.writeOID(OID_TO_STD_STRING(OID_PKCS7_DATA));
+    len += asn1Writer.writeSequence(len);
+
+    return len + childWrittenBytes;
+}
+
+void VirgilCMSEncryptedContent::asn1Read(VirgilAsn1Reader& asn1Reader) {
+    (void) asn1Reader.readSequence();
+    (void) asn1Reader.readOID(); // Ignore OID
+    contentEncryptionAlgorithm = asn1Reader.readData();
+    if (asn1Reader.readContextTag(kCMS_EncryptedContentTag) > 0) {
+        encryptedContent = asn1Reader.readOctetString();
+    }
+}
+
+

data/ext/native/src/lib/src/VirgilCMSEnvelopedData.cxx

@@ -0,0 +1,131 @@
+/**
+ * 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.
+ */
+
+#include <virgil/crypto/foundation/cms/VirgilCMSEnvelopedData.h>
+
+#include <virgil/crypto/foundation/VirgilSystemCryptoError.h>
+#include <virgil/crypto/foundation/asn1/VirgilAsn1Reader.h>
+#include <virgil/crypto/foundation/asn1/VirgilAsn1Writer.h>
+
+
+using virgil::crypto::foundation::cms::VirgilCMSEnvelopedData;
+using virgil::crypto::foundation::asn1::VirgilAsn1Reader;
+using virgil::crypto::foundation::asn1::VirgilAsn1Writer;
+/**
+ * @name ASN.1 Constants for CMS
+ */
+///@{
+static const unsigned char kCMS_OriginatorInfoTag = 0;
+static const unsigned char kCMS_KeyAgreeRecipientTag = 1;
+static const unsigned char kCMS_KEKRecipientTag = 2;
+static const unsigned char kCMS_PasswordRecipientTag = 3;
+static const unsigned char kCMS_OtherRecipientTag = 4;
+///@}
+
+size_t VirgilCMSEnvelopedData::asn1Write(VirgilAsn1Writer& asn1Writer, size_t childWrittenBytes) const {
+    size_t len = 0;
+    // encryptedContentInfo
+    len += asn1Writer.writeData(encryptedContent.toAsn1());
+    // recipientInfos
+    std::vector<VirgilByteArray> recipientInfos;
+    recipientInfos.reserve(keyTransRecipients.size() + passwordRecipients.size());
+
+    std::vector<VirgilCMSKeyTransRecipient>::const_iterator keyTransRecipientIt = keyTransRecipients.begin();
+    for (; keyTransRecipientIt != keyTransRecipients.end(); ++keyTransRecipientIt) {
+        recipientInfos.push_back(keyTransRecipientIt->toAsn1());
+    }
+
+    std::vector<VirgilCMSPasswordRecipient>::const_iterator passwordRecipientIt = passwordRecipients.begin();
+    for (; passwordRecipientIt != passwordRecipients.end(); ++passwordRecipientIt) {
+        VirgilAsn1Writer recipientAsn1Writer;
+        size_t recipientLen = recipientAsn1Writer.writeData(passwordRecipientIt->toAsn1());
+        recipientAsn1Writer.writeContextTag(kCMS_PasswordRecipientTag, recipientLen);
+        recipientInfos.push_back(recipientAsn1Writer.finish());
+    }
+
+    len += asn1Writer.writeSet(recipientInfos);
+    len += asn1Writer.writeInteger(defineVersion());
+    len += asn1Writer.writeSequence(len);
+
+    return len + childWrittenBytes;
+}
+
+void VirgilCMSEnvelopedData::asn1Read(VirgilAsn1Reader& asn1Reader) {
+    keyTransRecipients.clear();
+    passwordRecipients.clear();
+
+    (void) asn1Reader.readSequence();
+    (void) asn1Reader.readInteger(); // Ignore version
+    if (asn1Reader.readContextTag(kCMS_OriginatorInfoTag) > 0) {
+        (void) asn1Reader.readData(); // Ignore originatorInfo
+    }
+
+    size_t setLen = asn1Reader.readSet();
+    while (setLen != 0) {
+        VirgilByteArray recipientAsn1 = asn1Reader.readData();
+        VirgilAsn1Reader recipientAsn1Reader(recipientAsn1);
+
+        if (recipientAsn1Reader.readContextTag(kCMS_PasswordRecipientTag) > 0) {
+            VirgilCMSPasswordRecipient recipient;
+            recipient.fromAsn1(recipientAsn1Reader.readData());
+            passwordRecipients.push_back(recipient);
+        } else {
+            bool unsupportedRecipientInfoDefined =
+                    recipientAsn1Reader.readContextTag(kCMS_KeyAgreeRecipientTag) > 0 ||
+                            recipientAsn1Reader.readContextTag(kCMS_KEKRecipientTag) > 0 ||
+                            recipientAsn1Reader.readContextTag(kCMS_OtherRecipientTag) > 0;
+            if (unsupportedRecipientInfoDefined) {
+                throw make_error(VirgilCryptoError::UnsupportedAlgorithm, "Unsupported CMS RecipientInfo.");
+            } else {
+                VirgilCMSKeyTransRecipient recipient;
+                recipient.fromAsn1(recipientAsn1);
+                keyTransRecipients.push_back(recipient);
+            }
+        }
+        setLen = setLen > recipientAsn1.size() ? (setLen - recipientAsn1.size()) : 0;
+    }
+    encryptedContent.fromAsn1(asn1Reader.readData());
+}
+
+int VirgilCMSEnvelopedData::defineVersion() const {
+    if (passwordRecipients.size() > 0) {
+        return 3;
+    } else if (keyTransRecipients.size() > 0) {
+        return 2;
+    } else {
+        return 0;
+    }
+}

data/ext/native/src/lib/src/VirgilCMSKeyTransRecipient.cxx

@@ -0,0 +1,96 @@
+/**
+ * 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.
+ */
+
+#include <virgil/crypto/foundation/cms/VirgilCMSKeyTransRecipient.h>
+
+#include <virgil/crypto/foundation/VirgilSystemCryptoError.h>
+#include <virgil/crypto/foundation/asn1/VirgilAsn1Reader.h>
+#include <virgil/crypto/foundation/asn1/VirgilAsn1Writer.h>
+
+#include <virgil/crypto/internal/utils.h>
+
+using virgil::crypto::foundation::cms::VirgilCMSKeyTransRecipient;
+using virgil::crypto::foundation::asn1::VirgilAsn1Reader;
+using virgil::crypto::foundation::asn1::VirgilAsn1Writer;
+
+/**
+ * @name ASN.1 Constants for CMS
+ */
+///@{
+static const unsigned char kCMS_SubjectKeyTag = 0;
+static const int kCMS_KeyTransRecipientVersion = 2;
+///@}
+
+size_t VirgilCMSKeyTransRecipient::asn1Write(VirgilAsn1Writer& asn1Writer, size_t childWrittenBytes) const {
+    size_t len = 0;
+
+    checkRequiredField(encryptedKey);
+    len += asn1Writer.writeOctetString(encryptedKey);
+
+    checkRequiredField(keyEncryptionAlgorithm);
+    len += asn1Writer.writeData(keyEncryptionAlgorithm);
+
+    checkRequiredField(recipientIdentifier);
+    size_t recipientIdentifierLen = asn1Writer.writeOctetString(recipientIdentifier);
+    len += recipientIdentifierLen;
+    len += asn1Writer.writeContextTag(kCMS_SubjectKeyTag, recipientIdentifierLen);
+
+    len += asn1Writer.writeInteger(kCMS_KeyTransRecipientVersion);
+    len += asn1Writer.writeSequence(len);
+
+    return len + childWrittenBytes;
+}
+
+void VirgilCMSKeyTransRecipient::asn1Read(VirgilAsn1Reader& asn1Reader) {
+    (void) asn1Reader.readSequence();
+    int version = asn1Reader.readInteger();
+    if (version != kCMS_KeyTransRecipientVersion) {
+        throw make_error(VirgilCryptoError::InvalidFormat,
+                "KeyTransRecipientInfo structure is malformed. Incorrect CMS version number.");
+    }
+
+    if (asn1Reader.readContextTag(kCMS_SubjectKeyTag) > 0) {
+        recipientIdentifier = asn1Reader.readOctetString();
+    } else {
+        throw make_error(VirgilCryptoError::InvalidFormat,
+                "KeyTransRecipientInfo structure is malformed. Parameter 'rid' is not defined.");
+    }
+
+    keyEncryptionAlgorithm = asn1Reader.readData();
+    encryptedKey = asn1Reader.readOctetString();
+}
+
+

data/ext/native/src/lib/src/VirgilCMSPasswordRecipient.cxx

@@ -0,0 +1,93 @@
+/**
+ * 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.
+ */
+
+#include <virgil/crypto/foundation/cms/VirgilCMSPasswordRecipient.h>
+
+#include <virgil/crypto/foundation/VirgilSystemCryptoError.h>
+#include <virgil/crypto/foundation/asn1/VirgilAsn1Reader.h>
+#include <virgil/crypto/foundation/asn1/VirgilAsn1Writer.h>
+
+#include <virgil/crypto/internal/utils.h>
+
+using virgil::crypto::foundation::cms::VirgilCMSPasswordRecipient;
+using virgil::crypto::foundation::asn1::VirgilAsn1Reader;
+using virgil::crypto::foundation::asn1::VirgilAsn1Writer;
+
+/**
+ * @name ASN.1 Constants for CMS
+ */
+///@{
+static const unsigned char kCMS_KeyDerivationAlgorithmTag = 0;
+static const int kCMS_PasswordRecipientVersion = 0;
+///@}
+
+size_t VirgilCMSPasswordRecipient::asn1Write(VirgilAsn1Writer& asn1Writer, size_t childWrittenBytes) const {
+    size_t len = 0;
+
+    checkRequiredField(encryptedKey);
+    len += asn1Writer.writeOctetString(encryptedKey);
+
+    checkRequiredField(keyEncryptionAlgorithm);
+    len += asn1Writer.writeData(keyEncryptionAlgorithm);
+
+    if (!keyDerivationAlgorithm.empty()) {
+        size_t keyDerivationAlgorithmLen = asn1Writer.writeOctetString(keyDerivationAlgorithm);
+        len += keyDerivationAlgorithmLen;
+        len += asn1Writer.writeContextTag(kCMS_KeyDerivationAlgorithmTag, keyDerivationAlgorithmLen);
+    }
+
+    len += asn1Writer.writeInteger(kCMS_PasswordRecipientVersion);
+    len += asn1Writer.writeSequence(len);
+
+    return len + childWrittenBytes;
+}
+
+void VirgilCMSPasswordRecipient::asn1Read(VirgilAsn1Reader& asn1Reader) {
+    (void) asn1Reader.readSequence();
+    int version = asn1Reader.readInteger();
+    if (version != kCMS_PasswordRecipientVersion) {
+        throw make_error(VirgilCryptoError::InvalidFormat,
+                "PasswordRecipientInfo structure is malformed due to incorrect CMS version number.");
+    }
+
+    if (asn1Reader.readContextTag(kCMS_KeyDerivationAlgorithmTag) > 0) {
+        keyDerivationAlgorithm = asn1Reader.readData();
+    }
+    keyEncryptionAlgorithm = asn1Reader.readData();
+    encryptedKey = asn1Reader.readOctetString();
+}
+
+

data/ext/native/src/lib/src/VirgilChunkCipher.cxx

@@ -0,0 +1,215 @@
+/**
+ * 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.
+ */
+
+#include <virgil/crypto/VirgilChunkCipher.h>
+
+#include <cmath>
+#include <limits>
+
+#include <virgil/crypto/VirgilByteArrayUtils.h>
+#include <virgil/crypto/VirgilCryptoError.h>
+#include <virgil/crypto/foundation/VirgilSymmetricCipher.h>
+#include <virgil/crypto/foundation/VirgilAsymmetricCipher.h>
+
+using virgil::crypto::VirgilByteArray;
+using virgil::crypto::VirgilByteArrayUtils;
+using virgil::crypto::VirgilChunkCipher;
+using virgil::crypto::VirgilDataSource;
+using virgil::crypto::VirgilDataSink;
+using virgil::crypto::foundation::VirgilAsymmetricCipher;
+using virgil::crypto::foundation::VirgilSymmetricCipher;
+
+/**
+ * @name Contsants
+ */
+///@{
+static const char* const kCustomParameterKey_ChunkSize = "chunkSize";
+///@}
+
+namespace virgil { namespace crypto { namespace internal {
+
+static size_t adjustEncryptionChunkSize(size_t preferredChunkSize, size_t cipherBlockSize, bool isSupportPadding) {
+    if (isSupportPadding) {
+        if (preferredChunkSize < cipherBlockSize) {
+            return cipherBlockSize - 1;
+        } else {
+            return (size_t) (preferredChunkSize / cipherBlockSize) * cipherBlockSize - 1;
+        }
+    } else {
+        return preferredChunkSize;
+    }
+}
+
+static size_t adjustDecryptionChunkSize(
+        size_t encryptionChunkSize, size_t cipherBlockSize, bool isSupportPadding,
+        size_t authTagLength) {
+    if (isSupportPadding) {
+        return (size_t) ceil((double) encryptionChunkSize / cipherBlockSize) * cipherBlockSize + authTagLength;
+    } else {
+        return encryptionChunkSize + authTagLength;
+    }
+}
+
+static void increment_octets(VirgilByteArray& octets) {
+    for (VirgilByteArray::reverse_iterator it = octets.rbegin(); it != octets.rend(); ++it) {
+        if (++(*it) != 0) { break; }
+    }
+}
+
+static VirgilByteArray xor_octets(const VirgilByteArray& src, const VirgilByteArray& noise) {
+    size_t noiseByteReversePos = noise.size();
+    VirgilByteArray result(src);
+    for (VirgilByteArray::reverse_iterator it = result.rbegin();
+         it != result.rend() && noiseByteReversePos != 0; ++it, --noiseByteReversePos) {
+        *it ^= noise[noiseByteReversePos - 1];
+    }
+    return result;
+}
+
+static VirgilByteArray make_unique_nonce(const VirgilByteArray& nonce, const VirgilByteArray& counter) {
+    return xor_octets(nonce, counter);
+}
+
+static void process(
+        VirgilDataSource& source, VirgilDataSink& sink, VirgilSymmetricCipher& symmetricCipher,
+        size_t actualChunkSize, const VirgilByteArray& firstChunk = {}) {
+    VirgilByteArray nonceCounter(symmetricCipher.ivSize());
+    const VirgilByteArray nonce = symmetricCipher.iv();
+
+    VirgilByteArray data(firstChunk);
+    do {
+        // Collect data for full chunk
+        while (source.hasData() && data.size() < actualChunkSize) {
+            VirgilByteArrayUtils::append(data, source.read());
+        }
+        // Process (encrypt/decrypt)
+        while (data.size() >= actualChunkSize || (!data.empty() && !source.hasData())) {
+            // Reconfigure symmetric cipher
+            symmetricCipher.setIV(internal::make_unique_nonce(nonce, nonceCounter));
+            symmetricCipher.reset();
+            const VirgilByteArray chunk = VirgilByteArrayUtils::popBytes(data, actualChunkSize);
+            VirgilByteArray processedChunk;
+            VirgilByteArrayUtils::append(processedChunk, symmetricCipher.update(chunk));
+            VirgilByteArrayUtils::append(processedChunk, symmetricCipher.finish());
+            internal::increment_octets(nonceCounter);
+            VirgilDataSink::safeWrite(sink, processedChunk);
+        }
+    } while (source.hasData());
+}
+
+}}}
+
+void VirgilChunkCipher::encrypt(
+        VirgilDataSource& source, VirgilDataSink& sink, bool embedContentInfo, size_t preferredChunkSize) {
+    VirgilSymmetricCipher& symmetricCipher = initEncryption();
+
+    const size_t actualChunkSize = internal::adjustEncryptionChunkSize(preferredChunkSize, symmetricCipher.blockSize(),
+            symmetricCipher.isSupportPadding());
+    storeChunkSize(actualChunkSize);
+    buildContentInfo();
+
+    if (embedContentInfo) {
+        VirgilDataSink::safeWrite(sink, getContentInfo());
+    }
+
+    internal::process(source, sink, symmetricCipher, actualChunkSize);
+
+    clearCipherInfo();
+}
+
+void VirgilChunkCipher::decryptWithKey(
+        VirgilDataSource& source, VirgilDataSink& sink, const VirgilByteArray& recipientId,
+        const VirgilByteArray& privateKey, const VirgilByteArray& privateKeyPassword) {
+
+    const VirgilByteArray firstChunk = tryReadContentInfo(source);
+
+    VirgilSymmetricCipher& symmetricCipher = initDecryptionWithKey(recipientId, privateKey, privateKeyPassword);
+
+    const size_t actualChunkSize = internal::adjustDecryptionChunkSize(retrieveChunkSize(),
+            symmetricCipher.blockSize(), symmetricCipher.isSupportPadding(), symmetricCipher.authTagLength());
+
+    internal::process(source, sink, symmetricCipher, actualChunkSize, firstChunk);
+
+    clearCipherInfo();
+}
+
+void VirgilChunkCipher::decryptWithPassword(
+        VirgilDataSource& source, VirgilDataSink& sink, const VirgilByteArray& pwd) {
+
+    const VirgilByteArray firstChunk = tryReadContentInfo(source);
+
+    VirgilSymmetricCipher& symmetricCipher = initDecryptionWithPassword(pwd);
+
+    const size_t actualChunkSize = internal::adjustDecryptionChunkSize(retrieveChunkSize(),
+            symmetricCipher.blockSize(), symmetricCipher.isSupportPadding(), symmetricCipher.authTagLength());
+
+    internal::process(source, sink, symmetricCipher, actualChunkSize, firstChunk);
+
+    clearCipherInfo();
+}
+
+void VirgilChunkCipher::storeChunkSize(size_t chunkSize) {
+    if (chunkSize > std::numeric_limits<int>::max()) {
+        throw make_error(VirgilCryptoError::InvalidArgument, "Chunk size is too big.");
+    }
+    customParams().setInteger(str2bytes(kCustomParameterKey_ChunkSize), static_cast<int>(chunkSize));
+}
+
+size_t VirgilChunkCipher::retrieveChunkSize() const {
+    const int chunkSize = customParams().getInteger(str2bytes(kCustomParameterKey_ChunkSize));
+    if (chunkSize < 0) {
+        throw make_error(VirgilCryptoError::InvalidFormat, "Retrieved chunk size is negative.");
+    }
+    return static_cast<size_t>(chunkSize);
+}
+
+VirgilByteArray VirgilChunkCipher::tryReadContentInfo(VirgilDataSource& source) {
+    const size_t minDataSize = 16;
+    VirgilByteArray data;
+    while (data.size() < minDataSize && source.hasData()) {
+        VirgilByteArray nextData = source.read();
+        data.insert(data.end(), nextData.begin(), nextData.end());
+    }
+    size_t contentInfoSize = defineContentInfoSize(data);
+    if (contentInfoSize > 0) {
+        while (data.size() < contentInfoSize && source.hasData()) {
+            VirgilByteArray nextData = source.read();
+            data.insert(data.end(), nextData.begin(), nextData.end());
+        }
+        return VirgilCipherBase::tryReadContentInfo(data);
+    }
+    return data;
+}