virgil-crypto 2.0.2b0

data/ext/native/src/lib/cmake/config.cmake.in

@@ -0,0 +1,40 @@
+#
+# 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.
+#
+
+@PACKAGE_INIT@
+
+include ("${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake")
+check_required_components ("@PROJECT_NAME@")

data/ext/native/src/lib/include/CMakeLists.txt

@@ -0,0 +1,68 @@
+#
+# 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.
+#
+
+if (LIB_FILE_IO)
+    set (EXCLUDE_FILE_IO_PATTERN "fake-stream")
+else ()
+    set (EXCLUDE_FILE_IO_PATTERN "stream")
+endif ()
+
+if (LIB_LOW_LEVEL_API)
+    install (DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" DESTINATION "${INSTALL_INC_DIR_NAME}"
+        FILES_MATCHING
+        PATTERN "*.h"
+        PATTERN "internal" EXCLUDE
+        PATTERN ${EXCLUDE_FILE_IO_PATTERN} EXCLUDE
+    )
+else ()
+    install (DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" DESTINATION "${INSTALL_INC_DIR_NAME}"
+        FILES_MATCHING
+        PATTERN "*.h"
+        PATTERN "cms" EXCLUDE
+        PATTERN "internal" EXCLUDE
+        PATTERN "VirgilOID.h" EXCLUDE
+        PATTERN "VirgilAsn1Reader.h" EXCLUDE
+        PATTERN "VirgilAsn1Writer.h" EXCLUDE
+        PATTERN "VirgilKDF.h" EXCLUDE
+        PATTERN "PolarsslException.h" EXCLUDE
+        PATTERN "VirgilKeyPairGenerator.h" EXCLUDE
+        PATTERN "VirgilSymmetricCipher.h" EXCLUDE
+        PATTERN "VirgilAsymmetricCipher.h" EXCLUDE
+        PATTERN "VirgilRandom.h" EXCLUDE
+        PATTERN "VirgilPBE.h" EXCLUDE
+        PATTERN ${EXCLUDE_FILE_IO_PATTERN} EXCLUDE
+    )
+endif ()

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

@@ -0,0 +1,143 @@
+/**
+ * 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_BYTE_ARRAY_H
+#define VIRGIL_BYTE_ARRAY_H
+
+#include <cstring>
+#include <string>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <algorithm>
+
+namespace virgil { namespace crypto {
+
+/**
+ * @typedef VirgilByteArray
+ * @brief This type represents a sequence of bytes.
+ */
+typedef std::vector<unsigned char> VirgilByteArray;
+
+}}
+
+/**
+ * @name ByteArray conversation utilities
+ */
+/// @{
+#define VIRGIL_BYTE_ARRAY_TO_PTR_AND_LEN(array) reinterpret_cast<const unsigned char *>(array.data()), array.size()
+
+#define VIRGIL_BYTE_ARRAY_FROM_PTR_AND_LEN(ptr, len)\
+        virgil::crypto::VirgilByteArray(reinterpret_cast<virgil::crypto::VirgilByteArray::const_pointer >(ptr), \
+        reinterpret_cast<virgil::crypto::VirgilByteArray::const_pointer >((ptr) + (len)))
+///@}
+
+namespace virgil { namespace crypto {
+
+/**
+ * @brief Represents given string as byte array.
+ */
+inline VirgilByteArray str2bytes(const std::string& str) {
+    return VIRGIL_BYTE_ARRAY_FROM_PTR_AND_LEN(str.data(), str.size());
+}
+
+/**
+ * @brief Represent given byte array as string.
+ */
+inline std::string bytes2str(const VirgilByteArray& array) {
+    return std::string(reinterpret_cast<const char*>(array.data()), array.size());
+}
+
+/**
+ * @brief Translate given HEX string to the byte array.
+ * @param hexStr - HEX string.
+ * @return Byte array.
+ */
+inline VirgilByteArray hex2bytes(const std::string hexStr) {
+    VirgilByteArray result;
+    std::istringstream istr(hexStr);
+    char hexChars[3] = {0x00};
+    while (istr.read(hexChars, 2)) {
+        int byte = 0;
+        std::istringstream(hexChars) >> std::hex >> byte;
+        result.push_back((unsigned char) byte);
+    }
+    return result;
+}
+
+/**
+ * @brief Translate given byte array to the HEX string.
+ * @param array - byte array.
+ * @param formatted - if true, endline will be inserted every 16 bytes,
+ *                    and all bytes will be separated with whitespaces.
+ * @return HEX string.
+ */
+inline std::string bytes2hex(const VirgilByteArray& array, bool formatted = false) {
+    std::ostringstream hexStream;
+    hexStream << std::setfill('0');
+    for (size_t i = 0; i < array.size(); ++i) {
+        hexStream << std::hex << std::setw(2) << (int) array[i];
+        if (formatted) {
+            hexStream << (((i + 1) % 16 == 0) ? "\n" : " ");
+        }
+    }
+    return hexStream.str();
+}
+/**
+ * @name ByteArray security clear utilities
+ */
+///@{
+/**
+ * @brief Make all bytes zero.
+ */
+inline void bytes_zeroize(VirgilByteArray& array) {
+    size_t n = array.size();
+    volatile unsigned char* p = const_cast<unsigned char*>(array.data());
+    while (n--) { *p++ = 0; }
+}
+
+/**
+ * @brief Make all chars zero.
+ */
+inline void string_zeroize(std::string& str) {
+    size_t n = str.size();
+    volatile char* p = const_cast<char*>(str.c_str());
+    while (n--) { *p++ = '\0'; }
+}
+///@}
+
+}}
+#endif /* VIRGIL_BYTE_ARRAY_H */

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

@@ -0,0 +1,121 @@
+/**
+ * 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_BYTE_ARRAY_UTILS_H
+#define VIRGIL_CRYPTO_BYTE_ARRAY_UTILS_H
+
+#include <string>
+
+#include <virgil/crypto/VirgilByteArray.h>
+
+namespace virgil { namespace crypto {
+
+/**
+ * @brief This class contains conversion utils for byte sequence.
+ */
+class VirgilByteArrayUtils {
+public:
+    /**
+     * @brief Represents given JSON object as byte array in canonical form.
+     *
+     * @throw VirgilCryptoException with VirgilCryptoError::InvalidFormat, if JSON is invalid.
+     * @throw VirgilCryptoException with VirgilCryptoError::InvalidArgument,
+     *     if JSON contains unsupported data types: i.e. double.
+     *
+     * @note Conversion it to canonical form, ensure the same digest of JSON object,
+     *     that can be differently formatted.
+     *
+     * @note This method SHOULD be used before sign of JSON data object.
+     *
+     * @note Underlying canonical representation is ASN.1, but it can be changed in the future.
+     */
+    static VirgilByteArray jsonToBytes(const std::string& json);
+
+    /**
+     * @brief Represents given string as byte array.
+     */
+    static VirgilByteArray stringToBytes(const std::string& str);
+
+    /**
+     * @brief Represent given byte array as string.
+     */
+    static std::string bytesToString(const VirgilByteArray& array);
+
+    /**
+     * @brief Translate given HEX string to the byte array.
+     * @param hexStr - HEX string.
+     * @return Byte array.
+     */
+    static VirgilByteArray hexToBytes(const std::string& hexStr);
+
+    /**
+     * @brief Translate given byte array to the HEX string.
+     * @param array - byte array.
+     * @param formatted - if true, endline will be inserted every 16 bytes,
+     *                    and all bytes will be separated with whitespaces.
+     * @return HEX string.
+     */
+    static std::string bytesToHex(const VirgilByteArray& array, bool formatted = false);
+
+    /**
+     * @brief Make all bytes zero.
+     *
+     * This method SHOULD be used to securely delete sensitive data.
+     */
+    static void zeroize(VirgilByteArray& array);
+
+    /**
+     * @brief Append given bytes to the existing one.
+     * @param dst - destination.
+     * @param src - source.
+     */
+    static void append(VirgilByteArray& dst, const VirgilByteArray& src);
+
+    /**
+     * @brief Return first num bytes and remove it from the src
+     */
+    static VirgilByteArray popBytes(VirgilByteArray& src, size_t num);
+
+private:
+    /**
+     * @brief Deny object creation.
+     */
+    VirgilByteArrayUtils();
+};
+
+}}
+
+#endif /* VIRGIL_CRYPTO_BYTE_ARRAY_UTILS_H */

data/ext/native/src/lib/include/virgil/crypto/VirgilChunkCipher.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_CHUNK_CIPHER_H
+#define VIRGIL_CHUNK_CIPHER_H
+
+#include <cstdlib>
+
+#include <virgil/crypto/VirgilCipherBase.h>
+#include <virgil/crypto/VirgilByteArray.h>
+#include <virgil/crypto/VirgilDataSource.h>
+#include <virgil/crypto/VirgilDataSink.h>
+
+namespace virgil { namespace crypto {
+
+/**
+ * @brief This class provides high-level interface to encrypt / decrypt data splitted to chunks.
+ * @note Virgil Security keys is used for encryption and decryption.
+ * @note This class algorithms are not compatible with VirgilCipher and VirgilStreamCipher class algorithms.
+ */
+class VirgilChunkCipher : public VirgilCipherBase {
+public:
+    /**
+     * @name Constants
+     */
+    ///@{
+    /**
+     * @property kPreferredChunkSize
+     * @brief Recommended chunk size.
+     */
+    static constexpr size_t kPreferredChunkSize = 1024 * 1024;
+    ///@}
+public:
+    /**
+     * @brief Encrypt data read from given source and write it the sink.
+     * @param source - source of the data to be encrypted.
+     * @param sink - target sink for encrypted data.
+     * @param preferredChunkSize - chunk size that will appropriate.
+     * @param embedContentInfo - determines whether to embed content info the the encrypted data, or not.
+     * @note Store content info to use it for before decription process in future,
+     *     if embedContentInfo parameter is false @link getContentInfo() @endlink.
+     */
+    void encrypt(
+            VirgilDataSource& source, VirgilDataSink& sink, bool embedContentInfo = true,
+            size_t preferredChunkSize = kPreferredChunkSize);
+
+    /**
+     * @brief Decrypt data read from given source for recipient defined by id and private key,
+     *     and write it to the sink.
+     * @note Content info MUST be defined, if it was not embedded to the encrypted data.
+     * @see method setContentInfo().
+     */
+    void decryptWithKey(
+            VirgilDataSource& source, VirgilDataSink& sink, const VirgilByteArray& recipientId,
+            const VirgilByteArray& privateKey, const VirgilByteArray& privateKeyPassword = VirgilByteArray());
+
+    /**
+     * @brief Decrypt data read from given source for recipient defined by password,
+     *     and write it to the sink.
+     * @note Content info MUST be defined, if it was not embedded to the encrypted data.
+     * @see method setContentInfo().
+     */
+    void decryptWithPassword(VirgilDataSource& source, VirgilDataSink& sink, const VirgilByteArray& pwd);
+
+private:
+    /**
+     * @brief Store actual chunk size in the custom parameters.
+     */
+    void storeChunkSize(size_t chunkSize);
+
+    /**
+     * @brief Retrieve actual chunk size from the custom parameters.
+     */
+    size_t retrieveChunkSize() const;
+    /**
+     * @brief Attempt to read content info from the data source.
+     * @return Data that was read from the source and is not content info.
+     */
+    VirgilByteArray tryReadContentInfo(VirgilDataSource& source);
+};
+
+}}
+
+#endif /* VIRGIL_CHUNK_CIPHER_H */