virgil-crypto 2.0.2b0

data/ext/native/src/lib/include/virgil/crypto/VirgilCryptoException.h

@@ -0,0 +1,117 @@
+/**
+ * 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.
+ */
+
+#ifndef VIRGIL_CRYPTO_EXCEPTION_H
+#define VIRGIL_CRYPTO_EXCEPTION_H
+
+#include <string>
+#include <stdexcept>
+#include <system_error>
+
+namespace virgil { namespace crypto {
+
+/**
+ * @brief This only exception that crypto library can produce.
+ *
+ * To determine the real exception reason, error codes with conjuction with error category are used.
+ * Error codes can be found in the enumeration @link VirgilCryptoError @endlink.
+ *
+ * @ingroup Error
+ */
+class VirgilCryptoException : public std::exception {
+public:
+    /**
+     * @brief Initialize Exception with specific error code and correspond error category.
+     * @param ev Error value (code).
+     * @param ecat Error category.
+     */
+    VirgilCryptoException(int ev, const std::error_category& ecat);
+
+    /**
+     * @brief Initialize Exception with specific error code, correspond error category, and error description.
+     * @param ev Error value (code).
+     * @param ecat Error category.
+     * @param what Additional error description.
+     */
+    VirgilCryptoException(int ev, const std::error_category& ecat, const std::string& what);
+
+    /**
+     * @brief Initialize Exception with specific error code, correspond error category, and error description.
+     * @param ev Error value (code).
+     * @param ecat Error category.
+     * @param what Additional error description.
+     */
+    VirgilCryptoException(int ev, const std::error_category& ecat, const char* what);
+
+    /**
+     * Get string identifying exception.
+     *
+     * @return null terminated character sequence that may be used to identify the exception.
+     */
+    const char* what() const noexcept override;
+private:
+    std::error_condition condition_;
+    std::string what_;
+};
+
+/**
+ * @brief Unwind information about nested excpetions.
+ * @param exception - Top level exception.
+ * @param level - initial identation level.
+ * @return Formatted message of top level exception and all nested exceptions.
+ */
+std::string backtrace_exception(const std::exception& exception, size_t level = 0);
+
+}}
+
+//! @cond Doxygen_Suppress
+// TODO: Remove this when Clang compiler will be used from the Android NDK, possible in the release r13.
+#if defined(ANDROID) && defined(__GCC_ATOMIC_INT_LOCK_FREE) && __GCC_ATOMIC_INT_LOCK_FREE < 2
+namespace std {
+template<typename T>
+void throw_with_nested(const T& ex) {
+    throw ex;
+}
+template<typename T>
+void rethrow_if_nested(const T&) {
+    // Do nothing
+}
+}
+#endif
+//! @endcond
+
+
+#endif /* VIRGIL_CRYPTO_EXCEPTION_H */

data/ext/native/src/lib/include/virgil/crypto/VirgilCustomParams.h

@@ -0,0 +1,159 @@
+/**
+ * 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.
+ */
+
+#ifndef VIRGIL_CRYPTO_VIRGIL_CUSTOM_PARAMS_H
+#define VIRGIL_CRYPTO_VIRGIL_CUSTOM_PARAMS_H
+
+#include <map>
+#include <string>
+
+#include <virgil/crypto/VirgilByteArray.h>
+#include <virgil/crypto/foundation/asn1/VirgilAsn1Compatible.h>
+
+namespace virgil { namespace crypto {
+
+/**
+ * @brief Data object that represent ASN.1 structure: VirgilCustomParams.
+ */
+class VirgilCustomParams : public virgil::crypto::foundation::asn1::VirgilAsn1Compatible {
+public:
+    /**
+     * @name VirgilAsn1Compatible implementation
+     * @code
+     * Marshalling format:
+     *     VirgilCustomParams ::= SET SIZE (1..MAX) OF KeyValue
+     *
+     *     KeyValue ::= SEQUENCE {
+     *         key Key,
+     *         val Value
+     *     }
+     *
+     *     Key ::= UTF8String
+     *
+     *     Value ::= CHOICE {
+     *         int  [0] EXPLICIT INTEGER,
+     *         str  [1] EXPLICIT UTF8String,
+     *         data [2] EXPLICIT OCTET STRING
+     *     }
+     * @endcode
+     */
+    ///@{
+    virtual size_t asn1Write(
+            virgil::crypto::foundation::asn1::VirgilAsn1Writer& asn1Writer,
+            size_t childWrittenBytes = 0) const;
+
+    virtual void asn1Read(virgil::crypto::foundation::asn1::VirgilAsn1Reader& asn1Reader);
+    ///@}
+public:
+    /**
+     * @name Info
+     */
+    ///@{
+    /**
+     * @brief Define whether no one parameter is set.
+     */
+    bool isEmpty() const;
+    ///@}
+    /**
+     * @name Manage Parameters
+     * @note Key duplication is allowed for different parameter types.
+     */
+    ///@{
+    /**
+     * @brief Set parameter with type: Integer.
+     */
+    void setInteger(const VirgilByteArray& key, int value);
+
+    /**
+     * @brief Get parameter with type: Integer.
+     * @throw VirgilCryptoException if given key is absent.
+     */
+    int getInteger(const VirgilByteArray& key) const;
+
+    /**
+     * @brief Remove parameter with type: Integer.
+     * @note Do nothing if given key is absent.
+     */
+    void removeInteger(const VirgilByteArray& key);
+
+    /**
+     * @brief Set parameter with type: String.
+     */
+    void setString(const VirgilByteArray& key, const VirgilByteArray& value);
+
+    /**
+     * @brief Get parameter with type: String.
+     * @throw VirgilCryptoException if given key is absent.
+     */
+    VirgilByteArray getString(const VirgilByteArray& key) const;
+
+    /**
+     * @brief Remove parameter with type: String.
+     * @note Do nothing if given key is absent.
+     */
+    void removeString(const VirgilByteArray& key);
+
+    /**
+     * @brief Set parameter with type: Data.
+     */
+    void setData(const VirgilByteArray& key, const VirgilByteArray& value);
+
+    /**
+     * @brief Get parameter with type: Data.
+     * @throw VirgilCryptoException if given key is absent.
+     */
+    VirgilByteArray getData(const VirgilByteArray& key) const;
+
+    /**
+     * @brief Remove parameter with type: Data.
+     * @note Do nothing if given key is absent.
+     */
+    void removeData(const VirgilByteArray& key);
+
+    /**
+     * @brief Remove all parameters.
+     */
+    void clear();
+    ///@}
+private:
+    std::map<VirgilByteArray, int> intValues_;
+    std::map<VirgilByteArray, VirgilByteArray> stringValues_;
+    std::map<VirgilByteArray, VirgilByteArray> dataValues_;
+};
+
+}}
+
+#endif /* VIRGIL_CRYPTO_VIRGIL_CUSTOM_PARAMS_H */

data/ext/native/src/lib/include/virgil/crypto/VirgilDataSink.h

@@ -0,0 +1,77 @@
+/**
+ * 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.
+ */
+
+#ifndef VIRGIL_CRYPTO_VIRGIL_DATA_SINK_H
+#define VIRGIL_CRYPTO_VIRGIL_DATA_SINK_H
+
+#include <virgil/crypto/VirgilByteArray.h>
+
+namespace virgil { namespace crypto {
+
+/**
+ * @brief This is base class for output streams.
+ *
+ * Defines interface that allows write data to the output stream.
+ */
+class VirgilDataSink {
+public:
+    /**
+     * @brief Return true if target object is able to write data.
+     */
+    virtual bool isGood() = 0;
+
+    /**
+     * @brief Write data to the target object.
+     * @param data data to be written, SHOULD NOT be empty.
+     */
+    virtual void write(const VirgilByteArray& data) = 0;
+
+    /**
+     * @brief Write data to the sink in a safe way.
+     *
+     * Write only if data is not empty and sink is good, otherwise - do nothing
+     *
+     * @param sink sink to be written to.
+     * @param data data to be written.
+     */
+    static void safeWrite(VirgilDataSink& sink, const VirgilByteArray& data);
+
+    virtual ~VirgilDataSink() noexcept = default;
+};
+
+}}
+
+#endif /* VIRGIL_CRYPTO_VIRGIL_DATA_SINK_H */

data/ext/native/src/lib/include/virgil/crypto/VirgilDataSource.h

@@ -0,0 +1,66 @@
+/**
+ * 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.
+ */
+
+#ifndef VIRGIL_CRYPTO_VIRGIL_DATA_SOURCE_H
+#define VIRGIL_CRYPTO_VIRGIL_DATA_SOURCE_H
+
+#include <virgil/crypto/VirgilByteArray.h>
+
+namespace virgil { namespace crypto {
+
+/**
+ * @brief This is base class for input streams.
+ *
+ * Defines interface that allows read data from the input stream.
+ */
+class VirgilDataSource {
+public:
+    /**
+     * @brief Return true if target source still contains unread data.
+     */
+    virtual bool hasData() = 0;
+
+    /**
+     * @brief Return next portion of read data from target source.
+     */
+    virtual VirgilByteArray read() = 0;
+
+    virtual ~VirgilDataSource() noexcept = default;
+};
+
+}}
+
+#endif /* VIRGIL_CRYPTO_VIRGIL_DATA_SOURCE_H */

data/ext/native/src/lib/include/virgil/crypto/VirgilKeyPair.h

@@ -0,0 +1,274 @@
+/**
+ * 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.
+ */
+
+#ifndef VIRGIL_KEY_PAIR_H
+#define VIRGIL_KEY_PAIR_H
+
+#include <virgil/crypto/VirgilByteArray.h>
+
+namespace virgil { namespace crypto {
+
+/**
+ * @brief This class handles information about Virgil Security key pair.
+ */
+class VirgilKeyPair {
+public:
+    /**
+     * @brief Type of the keypair.
+     */
+    enum class Type {
+        RSA_256, ///< RSA 1024 bit (not recommended)
+        RSA_512, ///< RSA 1024 bit (not recommended)
+        RSA_1024, ///< RSA 1024 bit (not recommended)
+        RSA_2048, ///< RSA 2048 bit (not recommended)
+        RSA_3072, ///< RSA 3072 bit
+        RSA_4096, ///< RSA 4096 bit
+        RSA_8192, ///< RSA 8192 bit
+        EC_SECP192R1, ///< 192-bits NIST curve
+        EC_SECP224R1, ///< 224-bits NIST curve
+        EC_SECP256R1, ///< 256-bits NIST curve
+        EC_SECP384R1, ///< 384-bits NIST curve
+        EC_SECP521R1, ///< 521-bits NIST curve
+        EC_BP256R1, ///< 256-bits Brainpool curve
+        EC_BP384R1, ///< 384-bits Brainpool curve
+        EC_BP512R1, ///< 512-bits Brainpool curve
+        EC_SECP192K1, ///< 192-bits "Koblitz" curve
+        EC_SECP224K1, ///< 224-bits "Koblitz" curve
+        EC_SECP256K1, ///< 256-bits "Koblitz" curve
+        EC_CURVE25519, ///< Curve25519 as ECP deprecated format
+        FAST_EC_X25519,  ///< Curve25519
+        FAST_EC_ED25519, ///< Ed25519
+    };
+public:
+    /**
+     * @brief Generate new key pair given type.
+     * @param type - private key type to be generated.
+     * @param pwd - private key password.
+     */
+    static VirgilKeyPair generate(
+            VirgilKeyPair::Type type,
+            const VirgilByteArray& pwd = VirgilByteArray());
+
+    /**
+     * @brief Generate new key pair with recommended most safe type.
+     * @param pwd - private key password.
+     */
+    static VirgilKeyPair generateRecommended(
+            const VirgilByteArray& pwd = VirgilByteArray());
+
+    /**
+     * @brief Generate new key pair of the same type based on the donor key pair.
+     * @param donorKeyPair - public key or private key is used to determine the new key pair type.
+     * @param donorPrivateKeyPassword - donor private key password, optional if public key is defined.
+     * @param newKeyPairPassword - private key password of the new key pair.
+     */
+    static VirgilKeyPair generateFrom(
+            const VirgilKeyPair& donorKeyPair,
+            const VirgilByteArray& donorPrivateKeyPassword = VirgilByteArray(),
+            const VirgilByteArray& newKeyPairPassword = VirgilByteArray());
+
+    /**
+     * @name Keys validation
+     */
+    ///@{
+    /**
+     * @brief Check if a public-private pair of keys matches.
+     *
+     * @param publicKey - public key in DER or PEM format.
+     * @param privateKey - private key in DER or PEM format.
+     * @param privateKeyPassword - private key password if exists.
+     *
+     * @return true - if public-private pair of keys matches.
+     */
+    static bool isKeyPairMatch(
+            const VirgilByteArray& publicKey,
+            const VirgilByteArray& privateKey,
+            const VirgilByteArray& privateKeyPassword = VirgilByteArray());
+
+    /**
+     * @brief Check if given private key and it's password matches.
+     *
+     * @param key - private key in DER or PEM format.
+     * @param pwd - private key password.
+     *
+     * @return true - if private key and it's password matches.
+     */
+    static bool checkPrivateKeyPassword(
+            const VirgilByteArray& key,
+            const VirgilByteArray& pwd);
+
+    /**
+     * @brief Check if given private key is encrypted.
+     *
+     * @param privateKey - private key in DER or PEM format.
+     *
+     * @return true - if private key is encrypted.
+     */
+    static bool isPrivateKeyEncrypted(const VirgilByteArray& privateKey);
+    ///@}
+    /**
+     * @name Keys
+     */
+    ///@{
+    /**
+     * @brief Reset password for the given private key.
+     *
+     * Re-encrypt given Private Key with a new password.
+     *
+     * @param privateKey - Private Key that is encrypted with old password.
+     * @param oldPassword - current Private Key password.
+     * @param newPassword - new Private Key password.
+     *
+     * @return Private Key that is encrypted with the new password.
+     */
+    static VirgilByteArray resetPrivateKeyPassword(
+            const VirgilByteArray& privateKey,
+            const VirgilByteArray& oldPassword, const VirgilByteArray& newPassword);
+
+    /**
+     * @brief Return encrypted private key in PKCS#8 format.
+     *
+     * Encrypt the given private key and return result.
+     *
+     * @param privateKey - Private Key in the plain text.
+     * @param privateKeyPassword - new Private Key password.
+     *
+     * @throw VirgilCryptoException, with VirgilCryptoError::InvalidArgument if key is empty.
+     * @throw VirgilCryptoException, with VirgilCryptoError::InvalidPrivateKeyPassword if key is already encrypted.
+     * @throw VirgilCryptoException, with VirgilCryptoError::InvalidFormat if key has invalid format.
+     *
+     * @return Encrypted Private Key.
+     */
+    static VirgilByteArray encryptPrivateKey(
+            const VirgilByteArray& privateKey,
+            const VirgilByteArray& privateKeyPassword);
+
+    /**
+     * @brief Return plain (non encrypted) private key.
+     *
+     * Decrypt the given private key and return result.
+     *
+     * @param privateKey - Encrypted Private Key.
+     * @param privateKeyPassword - current Private Key password.
+     *
+     * @throw VirgilCryptoException, with VirgilCryptoError::InvalidPrivateKeyPassword if password is wrong.
+     * @throw VirgilCryptoException, with VirgilCryptoError::InvalidFormat if key has invalid format.
+     *
+     * @note It is unsafe to store Private Key in the plain text.
+     *
+     * @return Plain Private Key.
+     */
+    static VirgilByteArray decryptPrivateKey(
+            const VirgilByteArray& privateKey,
+            const VirgilByteArray& privateKeyPassword);
+
+    /**
+     * @brief Extract public key from the private key.
+     *
+     * @param privateKey - Private Key.
+     * @param privateKeyPassword - Private Key password.
+     *
+     * @return Public Key.
+     */
+    static VirgilByteArray extractPublicKey(
+            const VirgilByteArray& privateKey,
+            const VirgilByteArray& privateKeyPassword);
+
+    /**
+     * @brief Convert given public key to the PEM format.
+     *
+     * @param publicKey - Public Key to be converted.
+     * @return Public Key in the PEM fromat.
+     * @throw VirgilCryptoException, with VirgilCryptoError::InvalidFormat if key has invalid format.
+     */
+    static VirgilByteArray publicKeyToPEM(const VirgilByteArray& publicKey);
+
+    /**
+     * @brief Convert given public key to the DER format.
+     *
+     * @param publicKey - Public Key to be converted.
+     * @return Public Key in the DER fromat.
+     * @throw VirgilCryptoException, with VirgilCryptoError::InvalidFormat if key has invalid format.
+     */
+    static VirgilByteArray publicKeyToDER(const VirgilByteArray& publicKey);
+
+    /**
+     * @brief Convert given private key to the PEM format.
+     *
+     * @param publicKey - Private Key to be converted.
+     * @return Private Key in the PEM fromat.
+     * @throw VirgilCryptoException, with VirgilCryptoError::InvalidPrivateKeyPassword if password is wrong.
+     * @throw VirgilCryptoException, with VirgilCryptoError::InvalidFormat if key has invalid format.
+     */
+    static VirgilByteArray privateKeyToPEM(
+            const VirgilByteArray& privateKey,
+            const VirgilByteArray& privateKeyPassword = VirgilByteArray());
+    /**
+     * @brief Convert given private key to the DER format.
+     *
+     * @param publicKey - Private Key to be converted.
+     * @return Private Key in the DER fromat.
+     * @throw VirgilCryptoException, with VirgilCryptoError::InvalidPrivateKeyPassword if password is wrong.
+     * @throw VirgilCryptoException, with VirgilCryptoError::InvalidFormat if key has invalid format.
+     */
+    static VirgilByteArray privateKeyToDER(
+            const VirgilByteArray& privateKey,
+            const VirgilByteArray& privateKeyPassword = VirgilByteArray());
+    ///@}
+
+    /**
+     * @brief Initialize key pair with given public and private key.
+     */
+    VirgilKeyPair(const VirgilByteArray& publicKey, const VirgilByteArray& privateKey);
+
+    /**
+     * @brief Provide access to the public key.
+     */
+    VirgilByteArray publicKey() const;
+
+    /**
+     * @brief Provide access to the private key.
+     */
+    VirgilByteArray privateKey() const;
+
+private:
+    VirgilByteArray publicKey_;
+    VirgilByteArray privateKey_;
+};
+
+}}
+
+#endif /* VIRGIL_KEY_PAIR_H */