virgil-crypto 2.0.2b0

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

@@ -0,0 +1,122 @@
+/**
+ * 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/asn1/internal/VirgilAsn1Alg.h>
+
+#include <limits>
+#include <mbedtls/oid.h>
+
+#include <virgil/crypto/VirgilByteArrayUtils.h>
+#include <virgil/crypto/foundation/VirgilRandom.h>
+#include <virgil/crypto/foundation/VirgilSystemCryptoError.h>
+#include <virgil/crypto/foundation/asn1/VirgilAsn1Reader.h>
+#include <virgil/crypto/foundation/asn1/VirgilAsn1Writer.h>
+
+using virgil::crypto::VirgilByteArray;
+using virgil::crypto::VirgilByteArrayUtils;
+using virgil::crypto::VirgilCryptoException;
+using virgil::crypto::foundation::VirgilRandom;
+using virgil::crypto::foundation::asn1::internal::VirgilAsn1Alg;
+using virgil::crypto::foundation::asn1::VirgilAsn1Reader;
+using virgil::crypto::foundation::asn1::VirgilAsn1Writer;
+
+VirgilByteArray VirgilAsn1Alg::buildPKCS5(const VirgilByteArray& salt, size_t iterationCount) {
+    if (iterationCount > std::numeric_limits<int>::max()) {
+        throw make_error(VirgilCryptoError::InvalidArgument, "Iteration count is too big.");
+    }
+    VirgilRandom random(VirgilByteArrayUtils::stringToBytes("pkcs5_seed"));
+    VirgilAsn1Writer asn1Writer;
+    const char* oid = 0;
+    size_t oidLen;
+    // Write PBES2-params
+    size_t pbesLen = 0;
+    {
+        // Write PBES2-Enc
+        const mbedtls_cipher_type_t cipherType = MBEDTLS_CIPHER_AES_256_CBC;
+        system_crypto_handler(
+                mbedtls_oid_get_oid_by_cipher_alg(cipherType, &oid, &oidLen),
+                [](int) { std::throw_with_nested(make_error(VirgilCryptoError::UnsupportedAlgorithm)); }
+        );
+        const mbedtls_cipher_info_t* cipherInfo = mbedtls_cipher_info_from_type(cipherType);
+        if (cipherInfo == nullptr) {
+            throw make_error(VirgilCryptoError::UnsupportedAlgorithm);
+        }
+        size_t encLen = 0;
+        encLen += asn1Writer.writeOctetString(random.randomize(cipherInfo->iv_size));
+        encLen += asn1Writer.writeOID(std::string(oid, oidLen));
+        encLen += asn1Writer.writeSequence(encLen);
+
+        // Write PBES2-KDF
+        size_t prfLen = 0;
+        prfLen += asn1Writer.writeOID(std::string(MBEDTLS_OID_HMAC_SHA384, MBEDTLS_OID_SIZE(MBEDTLS_OID_HMAC_SHA384)));
+        prfLen += asn1Writer.writeSequence(prfLen);
+
+        size_t kdfLen = prfLen;
+        kdfLen += asn1Writer.writeInteger(static_cast<int>(iterationCount));
+        kdfLen += asn1Writer.writeOctetString(salt);
+        kdfLen += asn1Writer.writeSequence(kdfLen);
+        kdfLen +=
+                asn1Writer.writeOID(std::string(MBEDTLS_OID_PKCS5_PBKDF2, MBEDTLS_OID_SIZE(MBEDTLS_OID_PKCS5_PBKDF2)));
+        kdfLen += asn1Writer.writeSequence(kdfLen);
+
+        pbesLen += encLen + kdfLen;
+        pbesLen += asn1Writer.writeSequence(pbesLen);
+    }
+    // Write id-PBES2 OBJECT IDENTIFIER
+    pbesLen += asn1Writer.writeOID(std::string(MBEDTLS_OID_PKCS5_PBES2, MBEDTLS_OID_SIZE(MBEDTLS_OID_PKCS5_PBES2)));
+    asn1Writer.writeSequence(pbesLen);
+
+    return asn1Writer.finish();
+}
+
+VirgilByteArray VirgilAsn1Alg::buildPKCS12(const VirgilByteArray& salt, size_t iterationCount) {
+    if (iterationCount > std::numeric_limits<int>::max()) {
+        throw make_error(VirgilCryptoError::InvalidArgument, "Iteration count is too big.");
+    }
+    VirgilAsn1Writer asn1Writer;
+    // Write PBE-params
+    size_t pbesLen = 0;
+    pbesLen += asn1Writer.writeInteger(static_cast<int>(iterationCount));
+    pbesLen += asn1Writer.writeOctetString(salt);
+    pbesLen += asn1Writer.writeSequence(pbesLen);
+    // Write id-PBE OBJECT IDENTIFIER
+    pbesLen += asn1Writer.writeOID(
+            std::string(MBEDTLS_OID_PKCS12_PBE_SHA1_DES3_EDE_CBC,
+                    MBEDTLS_OID_SIZE(MBEDTLS_OID_PKCS12_PBE_SHA1_DES3_EDE_CBC)));
+    asn1Writer.writeSequence(pbesLen);
+
+    return asn1Writer.finish();
+}

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

@@ -0,0 +1,67 @@
+/**
+ * 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/asn1/VirgilAsn1Compatible.h>
+
+#include <virgil/crypto/foundation/asn1/VirgilAsn1Reader.h>
+#include <virgil/crypto/foundation/asn1/VirgilAsn1Writer.h>
+
+#include <virgil/crypto/foundation/VirgilSystemCryptoError.h>
+
+using virgil::crypto::VirgilByteArray;
+using virgil::crypto::VirgilCryptoException;
+
+using virgil::crypto::foundation::asn1::VirgilAsn1Compatible;
+using virgil::crypto::foundation::asn1::VirgilAsn1Reader;
+using virgil::crypto::foundation::asn1::VirgilAsn1Writer;
+
+VirgilByteArray VirgilAsn1Compatible::toAsn1() const {
+    VirgilAsn1Writer asn1Writer;
+    (void) asn1Write(asn1Writer);
+    return asn1Writer.finish();
+}
+
+void VirgilAsn1Compatible::fromAsn1(const VirgilByteArray& asn1) {
+    VirgilAsn1Reader asn1Reader(asn1);
+    asn1Read(asn1Reader);
+}
+
+
+void VirgilAsn1Compatible::checkRequiredField(const VirgilByteArray& param) const {
+    if (param.empty()) {
+        throw make_error(VirgilCryptoError::InvalidState);
+    }
+}

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

@@ -0,0 +1,190 @@
+/**
+ * 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/asn1/VirgilAsn1Reader.h>
+
+#include <mbedtls/asn1.h>
+
+#include <virgil/crypto/foundation/VirgilSystemCryptoError.h>
+
+using virgil::crypto::VirgilByteArray;
+using virgil::crypto::foundation::asn1::VirgilAsn1Reader;
+
+VirgilAsn1Reader::VirgilAsn1Reader() : p_(0), end_(0), data_() {
+}
+
+VirgilAsn1Reader::VirgilAsn1Reader(const VirgilByteArray& data) : p_(0), end_(0), data_() {
+    this->reset(data);
+}
+
+VirgilAsn1Reader::~VirgilAsn1Reader() noexcept {
+    p_ = 0;
+    end_ = 0;
+}
+
+void VirgilAsn1Reader::reset(const VirgilByteArray& data) {
+    data_ = data;
+    p_ = data_.data();
+    end_ = p_ + data_.size();
+}
+
+int VirgilAsn1Reader::readInteger() {
+    checkState();
+    int result;
+    system_crypto_handler(
+            mbedtls_asn1_get_int(&p_, end_, &result),
+            [](int){ std::throw_with_nested(make_error(VirgilCryptoError::InvalidFormat)); }
+    );
+    return result;
+}
+
+bool VirgilAsn1Reader::readBool() {
+    checkState();
+    int result;
+    system_crypto_handler(
+            mbedtls_asn1_get_bool(&p_, end_, &result),
+            [](int){ std::throw_with_nested(make_error(VirgilCryptoError::InvalidFormat)); }
+    );
+    return result == 0 ? false : true;
+}
+
+void VirgilAsn1Reader::readNull() {
+    checkState();
+    size_t len;
+    system_crypto_handler(
+            mbedtls_asn1_get_tag(&p_, end_, &len, MBEDTLS_ASN1_NULL),
+            [](int){ std::throw_with_nested(make_error(VirgilCryptoError::InvalidFormat)); }
+    );
+}
+
+size_t VirgilAsn1Reader::readContextTag(unsigned char tag) {
+    const unsigned char kAsn1Tag_Max = 0x1F;
+    if (tag > kAsn1Tag_Max) {
+        throw make_error(VirgilCryptoError::InvalidArgument, "Requested ASN.1 tag is greater then maximum allowed.");
+    }
+    if (p_ != 0 && end_ != 0 && p_ >= end_) {
+        // Expected optional tag located at the end of the ASN.1 structure is absent.
+        return 0;
+    }
+    checkState();
+    size_t len;
+    int result =
+            mbedtls_asn1_get_tag(&p_, end_, &len, MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | tag);
+    if (result == 0) {
+        return len;
+    } else if (result == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG) {
+        return 0;
+    }
+    throw make_error(VirgilCryptoError::InvalidFormat);
+}
+
+VirgilByteArray VirgilAsn1Reader::readOctetString() {
+    checkState();
+    size_t len;
+    system_crypto_handler(
+            mbedtls_asn1_get_tag(&p_, end_, &len, MBEDTLS_ASN1_OCTET_STRING),
+            [](int){ std::throw_with_nested(make_error(VirgilCryptoError::InvalidFormat)); }
+    );
+    p_ += len;
+    return VIRGIL_BYTE_ARRAY_FROM_PTR_AND_LEN(p_ - len, len);
+}
+
+VirgilByteArray VirgilAsn1Reader::readUTF8String() {
+    checkState();
+    size_t len;
+    system_crypto_handler(
+            mbedtls_asn1_get_tag(&p_, end_, &len, MBEDTLS_ASN1_UTF8_STRING),
+            [](int){ std::throw_with_nested(make_error(VirgilCryptoError::InvalidFormat)); }
+    );
+    p_ += len;
+    return VIRGIL_BYTE_ARRAY_FROM_PTR_AND_LEN(p_ - len, len);
+}
+
+VirgilByteArray VirgilAsn1Reader::readData() {
+    checkState();
+    size_t len;
+    unsigned char* dataStart = p_;
+    p_ += 1; // Ignore tag value
+    system_crypto_handler(
+            mbedtls_asn1_get_len(&p_, end_, &len),
+            [](int){ std::throw_with_nested(make_error(VirgilCryptoError::InvalidFormat)); }
+    );
+    p_ += len;
+    return VirgilByteArray(dataStart, p_);
+}
+
+
+std::string VirgilAsn1Reader::readOID() {
+    checkState();
+    size_t len;
+    system_crypto_handler(
+            mbedtls_asn1_get_tag(&p_, end_, &len, MBEDTLS_ASN1_OID),
+            [](int){ std::throw_with_nested(make_error(VirgilCryptoError::InvalidFormat)); }
+    );
+    p_ += len;
+    return std::string(reinterpret_cast<std::string::const_pointer>(p_ - len), len);
+}
+
+size_t VirgilAsn1Reader::readSequence() {
+    checkState();
+    size_t len;
+    system_crypto_handler(
+            mbedtls_asn1_get_tag(&p_, end_, &len, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE),
+            [](int){ std::throw_with_nested(make_error(VirgilCryptoError::InvalidFormat)); }
+    );
+    return len;
+}
+
+size_t VirgilAsn1Reader::readSet() {
+    checkState();
+    size_t len;
+    system_crypto_handler(
+            mbedtls_asn1_get_tag(&p_, end_, &len, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SET),
+            [](int){ std::throw_with_nested(make_error(VirgilCryptoError::InvalidFormat)); }
+    );
+    return len;
+}
+
+void VirgilAsn1Reader::checkState() {
+    if (p_ == 0 || end_ == 0) {
+        throw make_error(VirgilCryptoError::NotInitialized);
+    }
+    if (p_ >= end_) {
+        throw make_error(VirgilCryptoError::InvalidState, "Attempt to read empty ASN.1 structure.");
+    }
+}
+
+

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

@@ -0,0 +1,329 @@
+/**
+ * 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/asn1/VirgilAsn1Writer.h>
+
+#include <cmath>
+
+#include <tinyformat/tinyformat.h>
+#include <mbedtls/asn1.h>
+#include <mbedtls/asn1write.h>
+
+#include <virgil/crypto/internal/utils.h>
+#include <virgil/crypto/foundation/VirgilSystemCryptoError.h>
+
+using virgil::crypto::VirgilByteArray;
+
+using virgil::crypto::foundation::asn1::VirgilAsn1Writer;
+
+
+static const size_t kBufLenDefault = 128;
+
+static const size_t kAsn1TagValueSize = 1;
+static const size_t kAsn1LengthValueSize = 3;
+static const size_t kAsn1IntegerValueSize = kAsn1TagValueSize + kAsn1LengthValueSize + 8;
+static const size_t kAsn1BoolValueSize = 3;
+static const size_t kAsn1NullValueSize = kAsn1TagValueSize + 1;
+static const size_t kAsn1SizeMax = 65535 + kAsn1TagValueSize + 3; // According to MbedTLS restriction on TAG: LENGTH
+static const size_t kAsn1ContextTagMax = 0x1E;
+
+#define RETURN_POINTER_DIFF_AFTER_INVOCATION(pointer, invocation) \
+do { \
+    unsigned char *before = pointer; \
+    do { invocation; } while (0); \
+    unsigned char *after = pointer; \
+    return (ptrdiff_t)(before - after); \
+} while(0);
+
+VirgilAsn1Writer::VirgilAsn1Writer() : p_(0), start_(0), buf_(0), bufLen_(0) {
+    this->reset();
+}
+
+VirgilAsn1Writer::VirgilAsn1Writer(size_t capacity) : p_(0), start_(0), buf_(0), bufLen_(0) {
+    this->reset(capacity);
+}
+
+VirgilAsn1Writer::~VirgilAsn1Writer() noexcept {
+    dispose();
+}
+
+void VirgilAsn1Writer::reset() {
+    this->reset(kBufLenDefault);
+}
+
+void VirgilAsn1Writer::reset(size_t capacity) {
+    if (capacity == 0) {
+        throw make_error(VirgilCryptoError::InvalidArgument);
+    }
+    dispose();
+    relocateBuffer(capacity);
+}
+
+VirgilByteArray VirgilAsn1Writer::finish() {
+    checkState();
+    VirgilByteArray result = VIRGIL_BYTE_ARRAY_FROM_PTR_AND_LEN(p_, bufLen_ - (p_ - start_));
+    dispose();
+    return result;
+}
+
+size_t VirgilAsn1Writer::writeInteger(int value) {
+    checkState();
+    ensureBufferEnough(kAsn1IntegerValueSize);
+    RETURN_POINTER_DIFF_AFTER_INVOCATION(p_,
+            system_crypto_handler(
+                    mbedtls_asn1_write_int(&p_, start_, value)
+            )
+    );
+}
+
+size_t VirgilAsn1Writer::writeBool(bool value) {
+    checkState();
+    ensureBufferEnough(kAsn1BoolValueSize);
+    RETURN_POINTER_DIFF_AFTER_INVOCATION(p_,
+            system_crypto_handler(
+                    mbedtls_asn1_write_bool(&p_, start_, value)
+            )
+    );
+}
+
+size_t VirgilAsn1Writer::writeNull() {
+    checkState();
+    ensureBufferEnough(kAsn1NullValueSize);
+    RETURN_POINTER_DIFF_AFTER_INVOCATION(p_,
+            system_crypto_handler(
+                    mbedtls_asn1_write_null(&p_, start_)
+            )
+    );
+}
+
+size_t VirgilAsn1Writer::writeOctetString(const VirgilByteArray& data) {
+    checkState();
+    ensureBufferEnough(kAsn1TagValueSize + kAsn1LengthValueSize + data.size());
+    RETURN_POINTER_DIFF_AFTER_INVOCATION(p_,
+            system_crypto_handler(
+                    mbedtls_asn1_write_octet_string(&p_, start_, data.data(), data.size())
+            )
+    );
+}
+
+size_t VirgilAsn1Writer::writeUTF8String(const VirgilByteArray& data) {
+    checkState();
+    ensureBufferEnough(kAsn1TagValueSize + kAsn1LengthValueSize + data.size());
+    RETURN_POINTER_DIFF_AFTER_INVOCATION(p_,
+            {
+                system_crypto_handler(
+                        mbedtls_asn1_write_raw_buffer(&p_, start_, data.data(), data.size())
+                );
+                system_crypto_handler(
+                        mbedtls_asn1_write_len(&p_, start_, data.size())
+                );
+                system_crypto_handler(
+                        mbedtls_asn1_write_tag(&p_, start_, MBEDTLS_ASN1_UTF8_STRING)
+                );
+            }
+    );
+}
+
+size_t VirgilAsn1Writer::writeContextTag(unsigned char tag, size_t len) {
+    checkState();
+    if (tag > kAsn1ContextTagMax) {
+        throw make_error(VirgilCryptoError::InvalidArgument,
+                tfm::format("ASN.1 context tag is too big %s, maximum is %s.", tag, kAsn1ContextTagMax));
+    }
+    ensureBufferEnough(kAsn1TagValueSize + kAsn1LengthValueSize);
+    RETURN_POINTER_DIFF_AFTER_INVOCATION(p_,
+            {
+                system_crypto_handler(
+                        mbedtls_asn1_write_len(&p_, start_, len)
+                );
+                system_crypto_handler(
+                        mbedtls_asn1_write_tag(&p_, start_,
+                                MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | tag)
+                );
+            }
+    );
+}
+
+size_t VirgilAsn1Writer::writeData(const VirgilByteArray& data) {
+    checkState();
+    ensureBufferEnough(data.size());
+    RETURN_POINTER_DIFF_AFTER_INVOCATION(p_,
+            {
+                system_crypto_handler(
+                        mbedtls_asn1_write_raw_buffer(&p_, start_, data.data(), data.size())
+                );
+            }
+    );
+}
+
+
+size_t VirgilAsn1Writer::writeOID(const std::string& oid) {
+    checkState();
+    ensureBufferEnough(kAsn1TagValueSize + kAsn1LengthValueSize + oid.size());
+    RETURN_POINTER_DIFF_AFTER_INVOCATION(p_,
+            {
+                system_crypto_handler(
+                        mbedtls_asn1_write_oid(&p_, start_, oid.c_str(), oid.size())
+                );
+            }
+    );
+}
+
+size_t VirgilAsn1Writer::writeSequence(size_t len) {
+    checkState();
+    ensureBufferEnough(kAsn1TagValueSize + kAsn1LengthValueSize);
+    RETURN_POINTER_DIFF_AFTER_INVOCATION(p_,
+            {
+                system_crypto_handler(
+                        mbedtls_asn1_write_len(&p_, start_, len)
+                );
+                system_crypto_handler(
+                        mbedtls_asn1_write_tag(&p_, start_, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE)
+                );
+            }
+    );
+}
+
+size_t VirgilAsn1Writer::writeSet(const std::vector<VirgilByteArray>& set) {
+    checkState();
+
+    size_t setLength = 0;
+    for (std::vector<VirgilByteArray>::const_iterator it = set.begin(); it != set.end(); ++it) {
+        setLength += it->size();
+    }
+    ensureBufferEnough(kAsn1TagValueSize + kAsn1LengthValueSize + setLength);
+
+    std::vector<VirgilByteArray> orderedSet(set);
+    makeOrderedSet(orderedSet);
+    RETURN_POINTER_DIFF_AFTER_INVOCATION(p_,
+            {
+                for (std::vector<VirgilByteArray>::const_reverse_iterator it = orderedSet.rbegin();
+                     it != orderedSet.rend(); ++it) {
+                    system_crypto_handler(
+                            mbedtls_asn1_write_raw_buffer(&p_, start_, it->data(), it->size())
+                    );
+                }
+                system_crypto_handler(
+                        mbedtls_asn1_write_len(&p_, start_, setLength)
+                );
+                system_crypto_handler(
+                        mbedtls_asn1_write_tag(&p_, start_, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SET)
+                );
+            }
+    );
+}
+
+VirgilByteArray VirgilAsn1Writer::makeComparePadding(const VirgilByteArray& asn1, size_t finalSize) {
+    VirgilByteArray result = asn1;
+    if (result.size() >= finalSize) {
+        return result;
+    }
+    VirgilByteArray::value_type smallestByte = 0x00;
+    if (result.size() > 0) {
+        smallestByte = *std::min_element(result.begin(), result.end());
+        if (smallestByte != 0x00) {
+            --smallestByte;
+        }
+    }
+    result.resize(finalSize, smallestByte);
+    return result;
+}
+
+bool VirgilAsn1Writer::compare(const VirgilByteArray& first, const VirgilByteArray& second) {
+    if (first.size() > second.size()) {
+        VirgilByteArray paddedSecond = makeComparePadding(second, first.size());
+        return std::lexicographical_compare(first.begin(), first.end(), paddedSecond.begin(), paddedSecond.end());
+    } else if (second.size() > first.size()) {
+        VirgilByteArray paddedFirst = makeComparePadding(first, second.size());
+        return std::lexicographical_compare(paddedFirst.begin(), paddedFirst.end(), second.begin(), second.end());
+    } else {
+        return std::lexicographical_compare(first.begin(), first.end(), second.begin(), second.end());
+    }
+}
+
+void VirgilAsn1Writer::makeOrderedSet(std::vector<VirgilByteArray>& set) {
+    std::sort(set.begin(), set.end(), VirgilAsn1Writer::compare);
+}
+
+void VirgilAsn1Writer::checkState() {
+    if (p_ == 0 || start_ == 0) {
+        throw make_error(VirgilCryptoError::NotInitialized);
+    }
+}
+
+void VirgilAsn1Writer::relocateBuffer(size_t newBufLen) {
+    if (newBufLen < bufLen_) {
+        throw make_error(VirgilCryptoError::InvalidArgument, "Required buffer size is less then current.");
+    }
+    unsigned char* newBuf = new unsigned char[newBufLen];
+    size_t writtenBytes = 0;
+    if (buf_ && p_ && start_) {
+        writtenBytes = bufLen_ - (p_ - start_);
+        memcpy(newBuf + newBufLen - writtenBytes, p_, writtenBytes);
+        delete[] buf_;
+    }
+    buf_ = newBuf;
+    bufLen_ = newBufLen;
+    p_ = buf_ + bufLen_ - writtenBytes;
+    start_ = buf_;
+}
+
+void VirgilAsn1Writer::ensureBufferEnough(size_t len) {
+    checkState();
+    size_t unusedSpace = (size_t) (p_ - start_);
+    if (len > unusedSpace) {
+        const size_t usedSpace = bufLen_ - unusedSpace;
+        const size_t requiredLenMin = len + usedSpace;
+        if (requiredLenMin > kAsn1SizeMax) {
+            throw make_error(VirgilCryptoError::ExceededMaxSize, "ASN.1 structure size limit was exceeded.");
+        }
+        const size_t requiredLenMax =
+                (size_t) 1 << (size_t) (std::ceil(std::log((double) requiredLenMin) / std::log(2.0)));
+        const size_t adjustedLen = requiredLenMax > kAsn1SizeMax ? kAsn1SizeMax : requiredLenMax;
+        relocateBuffer(adjustedLen);
+    }
+}
+
+void VirgilAsn1Writer::dispose() noexcept {
+    p_ = 0;
+    start_ = 0;
+    bufLen_ = 0;
+    if (buf_) {
+        delete[] buf_;
+        buf_ = 0;
+    }
+}
+