virgil-crypto 2.0.2b0

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

@@ -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.
+ */
+
+#ifndef VIRGIL_CIPHER_H
+#define VIRGIL_CIPHER_H
+
+#include <vector>
+
+#include <virgil/crypto/VirgilCipherBase.h>
+#include <virgil/crypto/VirgilByteArray.h>
+
+namespace virgil { namespace crypto {
+
+/**
+ * @brief This class provides high-level interface to encrypt / decrypt data using Virgil Security keys.
+ */
+class VirgilCipher : public VirgilCipherBase {
+public:
+    /**
+     * @brief Encrypt given data.
+     * @param data - data to be encrypted.
+     * @param embedContentInfo - determines whether to embed content info the the encrypted data, or not.
+     * @note Store content info to use it for decription process, if embedContentInfo parameter is false.
+     * @see getContentInfo()
+     * @return encrypted data.
+     */
+    VirgilByteArray encrypt(const VirgilByteArray& data, bool embedContentInfo = true);
+
+    /**
+     * @brief Decrypt given data for recipient defined by id and private key.
+     * @note Content info MUST be defined, if it was not embedded to the encrypted data.
+     * @see method setContentInfo().
+     * @return Decrypted data.
+     */
+    VirgilByteArray decryptWithKey(
+            const VirgilByteArray& encryptedData,
+            const VirgilByteArray& recipientId, const VirgilByteArray& privateKey,
+            const VirgilByteArray& privateKeyPassword = VirgilByteArray());
+
+    /**
+     * @brief Decrypt given data for recipient defined by password.
+     * @note Content info MUST be defined, if it was not embedded to the encrypted data.
+     * @see method setContentInfo().
+     * @return Decrypted data.
+     */
+    VirgilByteArray decryptWithPassword(const VirgilByteArray& encryptedData, const VirgilByteArray& pwd);
+
+private:
+    /**
+     * @brief Decrypt given data.
+     * @return Decrypted data.
+     */
+    VirgilByteArray decrypt(
+            const VirgilByteArray& encryptedData,
+            virgil::crypto::foundation::VirgilSymmetricCipher& cipher);
+};
+
+}}
+
+#endif /* VIRGIL_CIPHER_H */

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

@@ -0,0 +1,302 @@
+/**
+ * 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_CIPHER_BASE_H
+#define VIRGIL_CIPHER_BASE_H
+
+#include <map>
+#include <set>
+#include <memory>
+
+#include <virgil/crypto/VirgilByteArray.h>
+#include <virgil/crypto/VirgilCustomParams.h>
+
+/**
+ * @name Forward declaration
+ */
+/// @{
+namespace virgil { namespace crypto { namespace foundation {
+class VirgilSymmetricCipher;
+}}}
+/// @}
+
+namespace virgil { namespace crypto {
+
+/**
+ * @brief This class provides configuration methods to all Virgil*Cipher classes.
+ */
+class VirgilCipherBase {
+public:
+    /**
+     * @brief Initialize submodules.
+     */
+    VirgilCipherBase();
+
+public:
+    /**
+     * @name Recipent management
+     */
+    ///@{
+    /**
+     * @brief Add recipient defined with id and public key.
+     * @param recipientId Recipient's unique identifier, MUST not be empty.
+     * @param publicKey Recipient's public key, MUST not be empty.
+     * @throw VirgilCryptoException with VirgilCryptoErrorCode::InvalidArgument, if invalid arguments are given.
+     */
+    void addKeyRecipient(const VirgilByteArray& recipientId, const VirgilByteArray& publicKey);
+
+    /**
+     * @brief Remove recipient with given identifier.
+     * @param recipientId Recipient's unique identifier.
+     * @note If recipient with given identifier is absent - do nothing.
+     */
+    void removeKeyRecipient(const VirgilByteArray& recipientId);
+
+    /**
+     * @brief Check whether recipient with given identifier exists.
+     *
+     * Search order:
+     *     1. Local structures - useful when cipher is used for encryption.
+     *     2. ContentInfo structure - useful when cipher is used for decryption.
+     *
+     * @param recipientId Recipient's unique identifier.
+     * @return true if recipient with given identifier exists, false - otherwise.
+     */
+    bool keyRecipientExists(const VirgilByteArray& recipientId) const;
+
+    /**
+     * @brief Add recipient defined with password.
+     *
+     * Use it for password based encryption.
+     *
+     * @param pwd Recipient's password, MUST not be empty.
+     * @throw VirgilCryptoException with VirgilCryptoErrorCode::InvalidArgument, if empty argument are given.
+     */
+    void addPasswordRecipient(const VirgilByteArray& pwd);
+
+    /**
+     * @brief Remove recipient with given password.
+     * @note If recipient with given password is absent - do nothing.
+     */
+    void removePasswordRecipient(const VirgilByteArray& pwd);
+
+    /**
+     * @brief Check whether recipient with given password exists.
+     *
+     * Search order:
+     *     1. Local structures - useful when cipher is used for encryption.
+     *
+     * @param password Recipient's unique identifier.
+     * @return true if recipient with given password exists, false - otherwise.
+     */
+    bool passwordRecipientExists(const VirgilByteArray& password) const;
+
+    /**
+     * @brief Remove all recipients.
+     */
+    void removeAllRecipients();
+    ///@}
+    /**
+     * @name Content Info Access / Management
+     *
+     * Content info is a structure that contains all necessary information
+     *     for future decription in secure form.
+     */
+    ///@{
+    /**
+     * @brief Returns encrypted data info.
+     */
+    /**
+     * @brief Return content info.
+     *
+     * Return Virgil Security Cryptogram, that contains public algorithm parameters that was used for encryption.
+     *
+     * @note Call this method after encryption process.
+     * @throw VirgilCryptoException with VirgilCryptoErrorCode::InvalidOperation,
+     *     if this function is used before any encryption operation.
+     */
+    VirgilByteArray getContentInfo() const;
+
+    /**
+     * @brief Create content info object from ASN.1 structure.
+     * @param contentInfo Virgil Security Cryptogram.
+     * @note Call this method before decryption process.
+     * @throw VirgilCryptoException with VirgilCryptoErrorCode::InvalidFormat, if content info can not be parsed.
+     */
+    void setContentInfo(const VirgilByteArray& contentInfo);
+
+    /**
+     * @brief Read content info size as part of the data.
+     * @return Size of the content info if it is exist as part of the data, 0 - otherwise.
+     */
+    static size_t defineContentInfoSize(const VirgilByteArray& data);
+    ///@}
+    /**
+     * @name Custom parameters Access / Management
+     *
+     * Custom parameters is a structure that contains additional user defined information
+     *     about encrypted data.
+     * @note This information is stored as part of the content info in unencrypted format.
+     */
+    ///@{
+    /**
+     * @brief Provide access to the object that handles custom parameters.
+     * @note Use this method to add custom parameters to the content info object.
+     * @note Use this method before encryption process.
+     */
+    VirgilCustomParams& customParams();
+
+    /**
+     * @brief Provide readonly access to the object that handles custom parameters.
+     * @note Use this method to read custom parameters from the content info object.
+     */
+    const VirgilCustomParams& customParams() const;
+    ///@}
+    /**
+     * @name Helpers to create shared key with Diffie–Hellman algorithms
+     */
+    ///@{
+    /**
+     * @brief Compute shared secret key on a given keys
+     *
+     * @param publicKey - alice public key.
+     * @param privateKey - bob private key.
+     * @param privateKeyPassword - bob private key password.
+     *
+     * @throw VirgilCryptoException - if keys are invalid or keys are not compatible.
+     *
+     * @warning Keys SHOULD be of the identical type, i.e. both of type Curve25519.
+     *
+     * @see VirgilKeyPair::generate(const VirgilKeyPair&, const VirgilByteArray&, const VirgilByteArray&)
+     */
+    static VirgilByteArray computeShared(
+            const VirgilByteArray& publicKey,
+            const VirgilByteArray& privateKey, const VirgilByteArray& privateKeyPassword = VirgilByteArray());
+    ///@}
+
+protected:
+    /**
+     * @brief Make attempt to read content info from the encrypted data.
+     *
+     * Payload content info if was detected in the encrypted data.
+     *
+     * @param encryptedData - data that was encrypted.
+     * return Encrypted data without content info.
+     */
+    VirgilByteArray tryReadContentInfo(const VirgilByteArray& encryptedData);
+
+    /**
+     * @brief Configures symmetric cipher for encryption.
+     * @return Configured cipher.
+     * @note cipher's key randomly generated.
+     * @note cipher's input vector is randomly generated.
+     */
+    virgil::crypto::foundation::VirgilSymmetricCipher& initEncryption();
+    /**
+     * @brief Configures symmetric cipher for encryption.
+     */
+    /**
+     * @brief Configures symmetric cipher for decryption.
+     * @param encryptedDataInfo - serialized encrypted data info.
+     * @param recipientId - id that corresponds to the user's private key.
+     * @param privateKey - user's private key.
+     * @param privateKeyPassword - user's private key password.
+     * @return Configured cipher.
+     */
+    virgil::crypto::foundation::VirgilSymmetricCipher& initDecryption(
+            const VirgilByteArray& encryptedDataInfo,
+            const VirgilByteArray& recipientId, const VirgilByteArray& privateKey,
+            const VirgilByteArray& privateKeyPassword = VirgilByteArray());
+
+    /**
+     * @brief Configures symmetric cipher for decryption based on the recipient's password.
+     * @param pwd - recipient's password.
+     * @return Configured cipher.
+     */
+    virgil::crypto::foundation::VirgilSymmetricCipher& initDecryptionWithPassword(const VirgilByteArray& pwd);
+
+    /**
+     * @brief Configures symmetric cipher for decryption based on the recipient's id and private key.
+     * @param recipientId - recipient's id.
+     * @param privateKey - recipient's private key.
+     * @param privateKeyPassword - recipient's private key password.
+     * @return Configured cipher.
+     */
+    virgil::crypto::foundation::VirgilSymmetricCipher& initDecryptionWithKey(
+            const VirgilByteArray& recipientId,
+            const VirgilByteArray& privateKey, const VirgilByteArray& privateKeyPassword);
+
+    /**
+     * @brief Return symmetric cipher configure by one of the methods:
+     *     initEncryption(), initDecryptionWithPassword(), initDecryptionWithKey.
+     */
+    virgil::crypto::foundation::VirgilSymmetricCipher& getSymmetricCipher();
+
+    /**
+     * @brief Build VirgilContentInfo object.
+     *
+     * This method SHOULD be called after encryption process is finished.
+     * @note This method SHOULD be called after encryption process is finished.
+     */
+    void buildContentInfo();
+
+    /**
+     * @brief Clear all information related to the cipher.
+     *
+     * Clear symmetric cipher and correspond internal states.
+     * @note This method SHOULD be called after encryption or decryption process is finished.
+     * @note You CAN not use symmetric cipher returned by the method @link getSymmetricCipher () @endlink,
+     *     after this method call.
+     */
+    void clearCipherInfo();
+
+public:
+    //! @cond Doxygen_Suppress
+    VirgilCipherBase(VirgilCipherBase&& rhs) noexcept;
+
+    VirgilCipherBase& operator=(VirgilCipherBase&& rhs) noexcept;
+
+    virtual ~VirgilCipherBase() noexcept;
+    //! @endcond
+private:
+    class Impl;
+
+    std::unique_ptr<Impl> impl_;
+};
+
+}}
+
+#endif /* VIRGIL_CIPHER_BASE_H */

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

@@ -0,0 +1,136 @@
+/**
+ * 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_ERROR_H
+#define VIRGIL_CRYPTO_ERROR_H
+
+#include <limits>
+#include <system_error>
+
+#include <virgil/crypto/VirgilCryptoException.h>
+
+namespace virgil { namespace crypto {
+
+/**
+ * @brief Specific error codes for the crypto library.
+ * @ingroup Error
+*/
+enum class VirgilCryptoError  {
+    Reserved = 0, ///< Should not be used.
+    EmptyParameter, ///< Given parameter is null or empty.
+    ExceededMaxSize, ///< Structure maximum size was exceeded.
+    InvalidArgument, ///< Argument given to a function is invalid.
+    InvalidFormat, ///< Data format is invalid.
+    InvalidPrivateKey, ///< Invalid format of the Private Key.
+    InvalidPrivateKeyPassword, ///< Private Key password mismatch.
+    InvalidPublicKey, ///< Invalid format of the Public Key.
+    InvalidSignature, ///< Invalid format of the Signature.
+    InvalidState, ///< Function call prerequisite is broken.
+    InvalidAuth, ///< Invalid authentication.
+    MismatchSignature, ///< Signature validation failed.
+    NotFoundKeyRecipient, ///< Recipient with given identifier is not found.
+    NotFoundPasswordRecipient, ///< Recipient with given password is not found.
+    NotInitialized, ///< Object is not initialized with specific algorithm, so can't be used.
+    NotSecure, ///< Security prerequisite is broken.
+    UnsupportedAlgorithm, ///< Algorithm is not supported in the current build.
+    Undefined = std::numeric_limits<int>::max()
+};
+
+/**
+ * @brief This is specific error category that contains information about crypto library errors.
+ * @ingroup Error
+ */
+class VirgilCryptoErrorCategory : public std::error_category {
+public:
+    /**
+     * @return Category name.
+     */
+    const char* name() const noexcept override;
+
+    /**
+     *
+     * @param ev Error value.
+     * @return Error description for given error value.
+     * @see VirgilCryptoError for specific error values.
+     */
+    std::string message(int ev) const noexcept override;
+};
+
+/**
+ * @brief Return singleton instance of the crypto error category.
+ * @return Instance of the crypto error categoty.
+ * @ingroup Error
+ */
+const VirgilCryptoErrorCategory& crypto_category() noexcept;
+
+/**
+ * @brief Build exception with given error value and corresond error category.
+ * @param ev Error value.
+ * @return Exception with given error value and corresond error category.
+ * @see VirgilCryptoError for specific error values.
+ * @ingroup Error
+ */
+inline VirgilCryptoException make_error(VirgilCryptoError ev) {
+    return VirgilCryptoException(static_cast<int>(ev), crypto_category());
+}
+
+/**
+ * @brief Build exception with given error value and corresond error category.
+ * @param ev Error value.
+ * @param what Additional error description.
+ * @return Exception with given error value and corresond error category.
+ * @see VirgilCryptoError for specific error values.
+ * @ingroup Error
+ */
+inline VirgilCryptoException make_error(VirgilCryptoError ev, const std::string& what) {
+    return VirgilCryptoException(static_cast<int>(ev), crypto_category(), what);
+}
+
+/**
+ * @brief Build exception with given error value and corresond error category.
+ * @param ev Error value.
+ * @param what Additional error description.
+ * @return Exception with given error value and corresond error category.
+ * @see VirgilCryptoError for specific error values.
+ * @ingroup Error
+ */
+inline VirgilCryptoException make_error(VirgilCryptoError ev, const char* what) {
+    return VirgilCryptoException(static_cast<int>(ev), crypto_category(), what);
+}
+}}
+
+
+#endif //VIRGIL_CRYPTO_ERROR_H