virgil-crypto 2.0.2b0

data/ext/native/src/wrappers/asmjs/wrapper.cxx

@@ -0,0 +1,340 @@
+/**
+ * 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 <string>
+#include <memory>
+
+#include <virgil/crypto/VirgilVersion.h>
+#include <virgil/crypto/VirgilByteArray.h>
+#include <virgil/crypto/VirgilByteArrayUtils.h>
+
+#include <virgil/crypto/foundation/VirgilHash.h>
+#include <virgil/crypto/foundation/VirgilBase64.h>
+#include <virgil/crypto/foundation/VirgilPBKDF.h>
+#include <virgil/crypto/foundation/VirgilRandom.h>
+#include <virgil/crypto/VirgilCustomParams.h>
+
+#include <virgil/crypto/VirgilKeyPair.h>
+
+#include <virgil/crypto/VirgilCipherBase.h>
+#include <virgil/crypto/VirgilCipher.h>
+#include <virgil/crypto/VirgilSigner.h>
+#include <virgil/crypto/VirgilTinyCipher.h>
+#include <virgil/crypto/VirgilDataSink.h>
+#include <virgil/crypto/VirgilDataSource.h>
+#include <virgil/crypto/VirgilStreamCipher.h>
+#include <virgil/crypto/VirgilStreamSigner.h>
+#include <virgil/crypto/VirgilChunkCipher.h>
+
+#include "@VIRGIL_EMBIND_FILE@"
+
+using namespace emscripten;
+using namespace virgil::crypto;
+using namespace virgil::crypto::foundation;
+
+namespace virgil { namespace crypto {
+
+static val VirgilByteArray_data(VirgilByteArray& data) {
+    return val(internal::toWireType(typed_memory_view(data.size(), data.data())));
+}
+
+static void VirgilByteArray_assign(VirgilByteArray& byteArray, val data) {
+    byteArray = vecFromJSArray<VirgilByteArray::value_type>(data);
+}
+
+static VirgilCustomParams* VirgilCipherBase_customParams(VirgilCipherBase& cipher) {
+    return &cipher.customParams();
+}
+
+static VirgilByteArray VirgilSigner_sign_1(VirgilSigner& signer, const VirgilByteArray& data,
+        const VirgilByteArray& privateKey) {
+    return signer.sign(data, privateKey);
+}
+
+static VirgilByteArray VirgilSigner_sign_2(VirgilSigner& signer, const VirgilByteArray& data,
+        const VirgilByteArray& privateKey, const VirgilByteArray& privateKeyPassword) {
+    return signer.sign(data, privateKey, privateKeyPassword);
+}
+
+static bool VirgilSigner_verify(VirgilSigner& signer, const VirgilByteArray& data,
+        const VirgilByteArray& sign, const VirgilByteArray& publicKey) {
+    return signer.verify(data, sign, publicKey);
+}
+
+class VirgilDataSinkWrapper : public wrapper<VirgilDataSink> {
+public:
+    EMSCRIPTEN_WRAPPER(VirgilDataSinkWrapper);
+    bool isGood() {
+        return call<bool>("isGood");
+    }
+    void write(const VirgilByteArray& data) {
+        return call<void>("write", data);
+    }
+};
+
+class VirgilDataSourceWrapper : public wrapper<VirgilDataSource> {
+public:
+    EMSCRIPTEN_WRAPPER(VirgilDataSourceWrapper);
+    bool hasData() {
+        return call<bool>("hasData");
+    }
+    VirgilByteArray read() {
+        return call<VirgilByteArray>("read");
+    }
+};
+
+}}
+
+EMSCRIPTEN_BINDINGS(virgil_crypto) {
+    class_<VirgilVersion>("VirgilVersion")
+        .class_function("asNumber", &VirgilVersion::asNumber)
+        .class_function("asString", &VirgilVersion::asString)
+        .class_function("fullName", &VirgilVersion::fullName)
+        .class_function("majorVersion", &VirgilVersion::majorVersion)
+        .class_function("minorVersion", &VirgilVersion::minorVersion)
+        .class_function("patchVersion", &VirgilVersion::patchVersion)
+    ;
+
+    register_vector<unsigned char>("VirgilByteArray")
+        .function("data", VirgilByteArray_data)
+        .function("assign", VirgilByteArray_assign)
+    ;
+
+    class_<VirgilKeyPair>("VirgilKeyPair")
+        .constructor<const VirgilByteArray&, const VirgilByteArray&>()
+        .function("publicKey", &VirgilKeyPair::publicKey)
+        .function("privateKey", &VirgilKeyPair::privateKey)
+        .class_function("generate", &VirgilKeyPair::generate)
+        .class_function("generateRecommended", &VirgilKeyPair::generateRecommended)
+        .class_function("generateFrom", &VirgilKeyPair::generateFrom)
+        .class_function("isKeyPairMatch", &VirgilKeyPair::isKeyPairMatch)
+        .class_function("checkPrivateKeyPassword", &VirgilKeyPair::checkPrivateKeyPassword)
+        .class_function("isPrivateKeyEncrypted", &VirgilKeyPair::isPrivateKeyEncrypted)
+        .class_function("resetPrivateKeyPassword", &VirgilKeyPair::resetPrivateKeyPassword)
+        .class_function("extractPublicKey", &VirgilKeyPair::extractPublicKey)
+        .class_function("encryptPrivateKey", &VirgilKeyPair::encryptPrivateKey)
+        .class_function("decryptPrivateKey", &VirgilKeyPair::decryptPrivateKey)
+        .class_function("publicKeyToPEM", &VirgilKeyPair::publicKeyToPEM)
+        .class_function("publicKeyToDER", &VirgilKeyPair::publicKeyToDER)
+        .class_function("privateKeyToPEM", &VirgilKeyPair::privateKeyToPEM)
+        .class_function("privateKeyToDER", &VirgilKeyPair::privateKeyToDER)
+    ;
+
+    enum_<VirgilKeyPair::Type>("VirgilKeyPairType")
+        .value("RSA_256", VirgilKeyPair::Type::RSA_256)
+        .value("RSA_512", VirgilKeyPair::Type::RSA_512)
+        .value("RSA_1024", VirgilKeyPair::Type::RSA_1024)
+        .value("RSA_2048", VirgilKeyPair::Type::RSA_2048)
+        .value("RSA_3072", VirgilKeyPair::Type::RSA_3072)
+        .value("RSA_4096", VirgilKeyPair::Type::RSA_4096)
+        .value("RSA_8192", VirgilKeyPair::Type::RSA_8192)
+        .value("EC_SECP192R1", VirgilKeyPair::Type::EC_SECP192R1)
+        .value("EC_SECP224R1", VirgilKeyPair::Type::EC_SECP224R1)
+        .value("EC_SECP256R1", VirgilKeyPair::Type::EC_SECP256R1)
+        .value("EC_SECP384R1", VirgilKeyPair::Type::EC_SECP384R1)
+        .value("EC_SECP521R1", VirgilKeyPair::Type::EC_SECP521R1)
+        .value("EC_BP256R1", VirgilKeyPair::Type::EC_BP256R1)
+        .value("EC_BP384R1", VirgilKeyPair::Type::EC_BP384R1)
+        .value("EC_BP512R1", VirgilKeyPair::Type::EC_BP512R1)
+        .value("EC_SECP192K1", VirgilKeyPair::Type::EC_SECP192K1)
+        .value("EC_SECP224K1", VirgilKeyPair::Type::EC_SECP224K1)
+        .value("EC_SECP256K1", VirgilKeyPair::Type::EC_SECP256K1)
+        .value("EC_CURVE25519", VirgilKeyPair::Type::EC_CURVE25519)
+        .value("FAST_EC_X25519", VirgilKeyPair::Type::FAST_EC_X25519)
+        .value("FAST_EC_ED25519", VirgilKeyPair::Type::FAST_EC_ED25519)
+    ;
+
+    class_<VirgilCipherBase>("VirgilCipherBase")
+        .function("addKeyRecipient", &VirgilCipherBase::addKeyRecipient)
+        .function("removeKeyRecipient", &VirgilCipherBase::removeKeyRecipient)
+        .function("keyRecipientExists", &VirgilCipherBase::keyRecipientExists)
+        .function("addPasswordRecipient", &VirgilCipherBase::addPasswordRecipient)
+        .function("removePasswordRecipient", &VirgilCipherBase::removePasswordRecipient)
+        .function("removeAllRecipients", &VirgilCipherBase::removeAllRecipients)
+        .function("getContentInfo", &VirgilCipherBase::getContentInfo)
+        .function("setContentInfo", &VirgilCipherBase::setContentInfo)
+        .function("customParams", &VirgilCipherBase_customParams, allow_raw_pointers())
+        .class_function("defineContentInfoSize", &VirgilCipherBase::defineContentInfoSize)
+        .class_function("computeShared", &VirgilCipherBase::computeShared)
+    ;
+
+    class_<VirgilCipher, base<VirgilCipherBase>>("VirgilCipher")
+        .constructor<>()
+        .function("encrypt", &VirgilCipher::encrypt)
+        .function("decryptWithKey", &VirgilCipher::decryptWithKey)
+        .function("decryptWithPassword", &VirgilCipher::decryptWithPassword)
+    ;
+
+    class_<VirgilSigner>("VirgilSigner")
+        .constructor<>()
+        .function("sign", &VirgilSigner_sign_1)
+        .function("sign", &VirgilSigner_sign_2)
+        .function("verify", &VirgilSigner_verify)
+    ;
+
+    class_<VirgilCustomParams>("VirgilCustomParams")
+        .constructor<>()
+        .function("isEmpty", &VirgilCustomParams::isEmpty)
+        .function("setInteger", &VirgilCustomParams::setInteger)
+        .function("getInteger", &VirgilCustomParams::getInteger)
+        .function("removeInteger", &VirgilCustomParams::removeInteger)
+        .function("setString", &VirgilCustomParams::setString)
+        .function("getString", &VirgilCustomParams::getString)
+        .function("removeString", &VirgilCustomParams::removeString)
+        .function("setData", &VirgilCustomParams::setData)
+        .function("getData", &VirgilCustomParams::getData)
+        .function("removeData", &VirgilCustomParams::removeData)
+        .function("clear", &VirgilCustomParams::clear)
+    ;
+
+    class_<VirgilByteArrayUtils>("VirgilByteArrayUtils")
+        .class_function("jsonToBytes", &VirgilByteArrayUtils::jsonToBytes)
+        .class_function("bytesToString", &VirgilByteArrayUtils::bytesToString)
+        .class_function("stringToBytes", &VirgilByteArrayUtils::stringToBytes)
+        .class_function("hexToBytes", &VirgilByteArrayUtils::hexToBytes)
+        .class_function("bytesToHex", &VirgilByteArrayUtils::bytesToHex)
+        .class_function("zeroize", &VirgilByteArrayUtils::zeroize)
+    ;
+
+    enum_<VirgilTinyCipher::PackageSize>("VirgilTinyCipherPackageSize")
+        .value("Min", VirgilTinyCipher::PackageSize_Min)
+        .value("Short_SMS", VirgilTinyCipher::PackageSize_Short_SMS)
+        .value("Long_SMS", VirgilTinyCipher::PackageSize_Long_SMS)
+    ;
+
+    class_<VirgilTinyCipher>("VirgilTinyCipher")
+        .constructor<>()
+        .constructor<size_t>()
+        .function("reset", &VirgilTinyCipher::reset)
+        .function("encrypt", &VirgilTinyCipher::encrypt)
+        .function("encryptAndSign", &VirgilTinyCipher::encryptAndSign)
+        .function("getPackageCount", &VirgilTinyCipher::getPackageCount)
+        .function("getPackage", &VirgilTinyCipher::getPackage)
+        .function("addPackage", &VirgilTinyCipher::addPackage)
+        .function("isPackagesAccumulated", &VirgilTinyCipher::isPackagesAccumulated)
+        .function("decrypt", &VirgilTinyCipher::decrypt)
+        .function("verifyAndDecrypt", &VirgilTinyCipher::verifyAndDecrypt)
+    ;
+
+    class_<VirgilDataSink>("VirgilDataSink")
+        .function("isGood", &VirgilDataSink::isGood, pure_virtual())
+        .function("write", &VirgilDataSink::write, pure_virtual())
+        .allow_subclass<VirgilDataSinkWrapper>("VirgilDataSinkWrapper")
+    ;
+
+    class_<VirgilDataSource>("VirgilDataSource")
+        .function("hasData", &VirgilDataSource::hasData, pure_virtual())
+        .function("read", &VirgilDataSource::read, pure_virtual())
+        .allow_subclass<VirgilDataSourceWrapper>("VirgilDataSourceWrapper")
+    ;
+
+    class_<VirgilStreamCipher, base<VirgilCipherBase>>("VirgilStreamCipher")
+        .constructor<>()
+        .function("encrypt", &VirgilStreamCipher::encrypt)
+        .function("decryptWithKey", &VirgilStreamCipher::decryptWithKey)
+        .function("decryptWithPassword", &VirgilStreamCipher::decryptWithPassword)
+    ;
+
+    class_<VirgilStreamSigner>("VirgilStreamSigner")
+        .constructor<>()
+        .function("sign", &VirgilStreamSigner::sign)
+        .function("verify", &VirgilStreamSigner::verify)
+    ;
+
+    class_<VirgilChunkCipher, base<VirgilCipherBase>>("VirgilChunkCipher")
+        .constructor<>()
+        .function("encrypt", &VirgilChunkCipher::encrypt)
+        .function("decryptWithKey", &VirgilChunkCipher::decryptWithKey)
+        .function("decryptWithPassword", &VirgilChunkCipher::decryptWithPassword)
+    ;
+}
+
+EMSCRIPTEN_BINDINGS(virgil_crypto_foundation) {
+    class_<VirgilHash>("VirgilHash")
+        .constructor<>()
+        .constructor<VirgilHash::Algorithm>()
+        .function("name", &VirgilHash::name)
+        .function("hash", &VirgilHash::hash)
+        .function("start", &VirgilHash::start)
+        .function("update", &VirgilHash::update)
+        .function("finish", &VirgilHash::finish)
+        .function("hmac", &VirgilHash::hmac)
+        .function("hmacStart", &VirgilHash::hmacStart)
+        .function("hmacReset", &VirgilHash::hmacReset)
+        .function("hmacUpdate", &VirgilHash::hmacUpdate)
+        .function("hmacFinish", &VirgilHash::hmacFinish)
+    ;
+
+    enum_<VirgilHash::Algorithm>("VirgilHashAlgorithm")
+        .value("MD5", VirgilHash::Algorithm::MD5)
+        .value("SHA1", VirgilHash::Algorithm::SHA1)
+        .value("SHA224", VirgilHash::Algorithm::SHA224)
+        .value("SHA256", VirgilHash::Algorithm::SHA256)
+        .value("SHA384", VirgilHash::Algorithm::SHA384)
+        .value("SHA512", VirgilHash::Algorithm::SHA512)
+    ;
+
+    class_<VirgilBase64>("VirgilBase64")
+        .class_function("encode", &VirgilBase64::encode)
+        .class_function("decode", &VirgilBase64::decode)
+    ;
+
+    class_<VirgilPBKDF>("VirgilPBKDF")
+        .constructor<>()
+        .constructor<const VirgilByteArray&>()
+        .constructor<const VirgilByteArray&, unsigned int>()
+        .function("getSalt", &VirgilPBKDF::getSalt)
+        .function("getIterationCount", &VirgilPBKDF::getIterationCount)
+        .function("setAlgorithm", &VirgilPBKDF::setAlgorithm)
+        .function("getAlgorithm", &VirgilPBKDF::getAlgorithm)
+        .function("setHashAlgorithm", &VirgilPBKDF::setHashAlgorithm)
+        .function("getHashAlgorithm", &VirgilPBKDF::getHashAlgorithm)
+        .function("enableRecommendationsCheck", &VirgilPBKDF::enableRecommendationsCheck)
+        .function("disableRecommendationsCheck", &VirgilPBKDF::disableRecommendationsCheck)
+        .function("derive", &VirgilPBKDF::derive)
+    ;
+
+    enum_<VirgilPBKDF::Algorithm>("VirgilPBKDFAlgorithm")
+        .value("PBKDF2", VirgilPBKDF::Algorithm::PBKDF2)
+    ;
+
+    class_<VirgilRandom>("VirgilRandom")
+        .constructor<const VirgilByteArray&>()
+        .function("randomizeBytes", select_overload<VirgilByteArray(size_t)>(&VirgilRandom::randomize))
+        .function("randomizeNumber", select_overload<size_t()>(&VirgilRandom::randomize))
+        .function("randomizeNumberInRange", select_overload<size_t(size_t, size_t)>(&VirgilRandom::randomize))
+    ;
+}

data/ext/native/src/wrappers/java/CMakeLists.txt

@@ -0,0 +1,156 @@
+#
+# 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.
+#
+
+cmake_minimum_required (VERSION 3.2 FATAL_ERROR)
+
+project (${WRAPPED_LIB_NAME}_java)
+
+# Configure Java
+set (JAVA_MODULE_NAME ${PROJECT_NAME})
+set (JAVA_JAR_NAME ${JAVA_MODULE_NAME})
+set (JAVA_JAR_TARGET_NAME ${JAVA_MODULE_NAME}_jar)
+set (SWIG_MODULE_NAME ${JAVA_MODULE_NAME})
+
+# Find Java
+find_host_package (Java REQUIRED)
+include (UseJava)
+
+# Find Java JNI
+if (ANDROID)
+    find_path (JAVA_INCLUDE_PATH jni.h)
+    set (JNI_INCLUDE_DIRS ${JAVA_INCLUDE_PATH})
+else (ANDROID)
+    find_host_package (JNI REQUIRED)
+endif (ANDROID)
+include_directories (SYSTEM ${JNI_INCLUDE_DIRS})
+
+# Make sure the nested directory structure exists
+set (JAVA_BINARY_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin CACHE INTERNAL "")
+set (JAVA_SWIG_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/src CACHE INTERNAL "")
+file (MAKE_DIRECTORY ${JAVA_BINARY_DIRECTORY})
+file (MAKE_DIRECTORY ${JAVA_SWIG_OUTPUT_DIRECTORY})
+
+# Configure SWIG
+find_host_package (SWIG REQUIRED)
+include (${SWIG_USE_FILE})
+
+set (CMAKE_SWIG_OUTDIR ${JAVA_SWIG_OUTPUT_DIRECTORY})
+set (CMAKE_SWIG_FLAGS "")
+
+set (SWIG_WRAP_COPY_CONSTRUCTOR YES)
+set (SWIG_WRAP_NAMESPACE NO)
+set (WRAPPER_INTERFACE_FILE "${CMAKE_CURRENT_BINARY_DIR}/wrapper.i")
+configure_file (
+    "${wrappers_SOURCE_DIR}/swig/wrapper.i.in"
+    "${WRAPPER_INTERFACE_FILE}"
+)
+
+set_property (SOURCE "${WRAPPER_INTERFACE_FILE}" PROPERTY CPLUSPLUS ON)
+set_property (
+    SOURCE "${WRAPPER_INTERFACE_FILE}" PROPERTY SWIG_FLAGS "-ignoremissing;-package;com.virgilsecurity.crypto"
+)
+
+swig_add_module (${JAVA_MODULE_NAME} java ${WRAPPER_INTERFACE_FILE})
+swig_link_libraries (${JAVA_MODULE_NAME} ${WRAPPED_LIB_NAME})
+
+set (JAVA_SWIG_TARGET_NAME ${SWIG_MODULE_${JAVA_MODULE_NAME}_REAL_NAME})
+
+# Configure assembly
+set_target_properties (${JAVA_SWIG_TARGET_NAME}
+        PROPERTIES OUTPUT_NAME ${JAVA_MODULE_NAME})
+set_target_properties (${JAVA_SWIG_TARGET_NAME}
+        PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${JAVA_BINARY_DIRECTORY})
+set_target_properties (${JAVA_SWIG_TARGET_NAME}
+        PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+if (UNIX AND NOT (CMAKE_SYSTEM_NAME MATCHES "Darwin"))
+    if (CMAKE_SYSTEM_NAME MATCHES "Android")
+        string(REPLACE "<CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG><TARGET_SONAME>" ""
+                CMAKE_CXX_CREATE_SHARED_MODULE "${CMAKE_CXX_CREATE_SHARED_MODULE}")
+    else ()
+        set_target_properties (${JAVA_SWIG_TARGET_NAME}
+                PROPERTIES NO_SONAME OFF VERSION ${VIRGIL_VERSION} SOVERSION ${VIRGIL_SOVERSION})
+    endif ()
+endif ()
+
+# Copy additional source files
+file (GLOB_RECURSE JAVA_SRC "${CMAKE_CURRENT_SOURCE_DIR}/src/*.java")
+foreach (JAVA_FILE ${JAVA_SRC})
+    string (REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/src/" "" JAVA_FILE_NAME ${JAVA_FILE})
+    configure_file (
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/${JAVA_FILE_NAME}
+        ${JAVA_SWIG_OUTPUT_DIRECTORY}/${JAVA_FILE_NAME}
+        @ONLY
+    )
+endforeach (JAVA_FILE)
+
+# Add assembly dependencies
+add_jar (${JAVA_JAR_TARGET_NAME}
+    "${CMAKE_CURRENT_BINARY_DIR}/src/VirgilStreamDataSink.java"
+    "${CMAKE_CURRENT_BINARY_DIR}/src/VirgilStreamDataSource.java"
+    OUTPUT_NAME ${JAVA_JAR_NAME}
+)
+add_dependencies (${JAVA_JAR_TARGET_NAME} ${JAVA_SWIG_TARGET_NAME})
+
+# Payload 'java_sources' file with generated classes
+get_property (JAVA_CLASS_DIR TARGET ${JAVA_JAR_TARGET_NAME} PROPERTY CLASS_DIR)
+if (NOT JAVA_CLASS_DIR)
+    get_property (JAVA_CLASS_DIR TARGET ${JAVA_JAR_TARGET_NAME} PROPERTY CLASSDIR)
+endif ()
+set (JAVA_SOURCE_LIST_FILE ${JAVA_CLASS_DIR}/java_sources)
+
+add_custom_command (TARGET ${JAVA_SWIG_TARGET_NAME} POST_BUILD
+        COMMAND ${CMAKE_COMMAND}
+        ARGS
+            -DSRC_DIR:PATH=${JAVA_SWIG_OUTPUT_DIRECTORY}
+            -DDST_FILE:PATH=${JAVA_SOURCE_LIST_FILE}
+            -DGLOBBING_EXPRESSION:STRING="*.java"
+            -P ${CMAKE_SOURCE_DIR}/cmake/aux_source_directory_to_file.cmake
+        COMMENT "Create java source list file: ${JAVA_SOURCE_LIST_FILE}."
+    )
+
+# Install
+set (PLATFORM_VERSION "${Java_VERSION_MAJOR}.${Java_VERSION_MINOR}" PARENT_SCOPE)
+
+if (ANDROID)
+    install (TARGETS ${JAVA_SWIG_TARGET_NAME}
+            DESTINATION "${INSTALL_LIB_DIR_NAME}/${ANDROID_INSTALL_JNI_DIR_NAME}")
+else ()
+    install (TARGETS ${JAVA_SWIG_TARGET_NAME}
+            DESTINATION "${INSTALL_LIB_DIR_NAME}")
+endif (ANDROID)
+
+install_jar (${JAVA_JAR_TARGET_NAME} "${INSTALL_LIB_DIR_NAME}")