Merge pull request #30239 from Faless/crypto/crypto_core

CryptoCore class to access to base crypto utils.

26 files changed, 372 insertions, 1380 deletions

diff --git a/COPYRIGHT.txt b/COPYRIGHT.txt
index 5431e2b403..1759c935b8 100644
--- a/COPYRIGHT.txt
+++ b/COPYRIGHT.txt
@@ -250,20 +250,6 @@ Copyright: 1998-2010, Gilles Vollant
  2009-2010, Mathias Svensson
 License: Zlib
 
-Files: ./thirdparty/misc/aes256.cpp
- ./thirdparty/misc/aes256.h
- ./thirdparty/misc/sha256.c
- ./thirdparty/misc/sha256.h
-Comment: AES-256 and SHA-256 implementation
-Copyright: 2007-2011, Ilya O. Levin
-License: ISC
-
-Files: ./thirdparty/misc/base64.c
- ./thirdparty/misc/base64.h
-Comment: BASE64 conversion methods
-Copyright: Ari Edelkind
-License: public-domain
-
 Files: ./thirdparty/misc/clipper.cpp
  ./thirdparty/misc/clipper.hpp
 Comment: Clipper
@@ -299,12 +285,6 @@ Comment: libjingle
 Copyright: 2012-2013, Google Inc.
 License: BSD-3-clause
 
-Files: ./thirdparty/misc/md5.cpp
- ./thirdparty/misc/md5.h
-Comment: MD5 Message Digest Algorithm
-Copyright: 1990, RSA Data Security, Inc.
-License: RSA-MD
-
 Files: ./thirdparty/misc/mikktspace.c
  ./thirdparty/misc/mikktspace.h
 Comment: Tangent Space Normal Maps implementation
@@ -1072,19 +1052,6 @@ License: FTL
    Robert Wilhelm    <robert.wilhelm@freetype.org>
    Werner Lemberg    <werner.lemberg@freetype.org>
 
-License: ISC
- Permission to use, copy, modify, and/or distribute this software for any
- purpose with or without fee is hereby granted, provided that the above
- copyright notice and this permission notice appear in all copies.
- .
- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
 License: LGPL-2.1+SLE (libwebsockets)
  Libwebsockets and included programs are provided under the terms of the GNU
  Library General Public License (LGPL) 2.1, with the following exceptions:
@@ -2101,24 +2068,6 @@ License: OFL-1.1
  DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE.
 
-License: RSA-MD
- License to copy and use this software is granted provided that it is
- identified as the "RSA Data Security, Inc. MD5 Message-Digest Algorithm"
- in all material mentioning or referencing this software or this function.
- .
- License is also granted to make and use derivative works provided that such
- works are identified as "derived from the RSA Data Security, Inc. MD5
- Message-Digest Algorithm" in all material mentioning or referencing the
- derived work.
- .
- RSA Data Security, Inc. makes no representations concerning either the
- merchantability of this software or the suitability of this software for
- any particular purpose. It is provided "as is" without express or implied
- warranty of any kind.
- .
- These notices must be retained in any copies of any part of this
- documentation and/or software.
-
 License: Zlib
  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
diff --git a/core/SCsub b/core/SCsub
index 166b7083e4..6389cd176c 100644
--- a/core/SCsub
+++ b/core/SCsub
@@ -47,15 +47,11 @@ env_thirdparty.disable_warnings()
 thirdparty_misc_dir = "#thirdparty/misc/"
 thirdparty_misc_sources = [
     # C sources
-    "base64.c",
     "fastlz.c",
-    "sha256.c",
     "smaz.c",
 
     # C++ sources
-    "aes256.cpp",
     "hq2x.cpp",
-    "md5.cpp",
     "pcg.cpp",
     "triangulator.cpp",
     "clipper.cpp",
diff --git a/core/bind/core_bind.cpp b/core/bind/core_bind.cpp
index ba9bd10bfd..382ab31f6d 100644
--- a/core/bind/core_bind.cpp
+++ b/core/bind/core_bind.cpp
@@ -34,13 +34,12 @@
 #include "core/io/file_access_encrypted.h"
 #include "core/io/json.h"
 #include "core/io/marshalls.h"
+#include "core/math/crypto_core.h"
 #include "core/math/geometry.h"
 #include "core/os/keyboard.h"
 #include "core/os/os.h"
 #include "core/project_settings.h"
 
-#include "thirdparty/misc/base64.h"
-
 /**
  *  Time constants borrowed from loc_time.h
  */
@@ -2438,7 +2437,8 @@ String _Marshalls::variant_to_base64(const Variant &p_var, bool p_full_objects)
 	b64buff.resize(b64len);
 	PoolVector<uint8_t>::Write w64 = b64buff.write();
 
-	int strlen = base64_encode((char *)(&w64[0]), (char *)(&w[0]), len);
+	size_t strlen = 0;
+	ERR_FAIL_COND_V(CryptoCore::b64_encode(&w64[0], b64len, &strlen, &w[0], len) != OK, String());
 	//OS::get_singleton()->print("len is %i, vector size is %i\n", b64len, strlen);
 	w64[strlen] = 0;
 	String ret = (char *)&w64[0];
@@ -2455,7 +2455,8 @@ Variant _Marshalls::base64_to_variant(const String &p_str, bool p_allow_objects)
 	buf.resize(strlen / 4 * 3 + 1);
 	PoolVector<uint8_t>::Write w = buf.write();
 
-	int len = base64_decode((char *)(&w[0]), (char *)cstr.get_data(), strlen);
+	size_t len = 0;
+	ERR_FAIL_COND_V(CryptoCore::b64_decode(&w[0], buf.size(), &len, (unsigned char *)cstr.get_data(), strlen) != OK, Variant());
 
 	Variant v;
 	Error err = decode_variant(v, &w[0], len, NULL, p_allow_objects);
@@ -2474,7 +2475,8 @@ String _Marshalls::raw_to_base64(const PoolVector<uint8_t> &p_arr) {
 	b64buff.resize(b64len);
 	PoolVector<uint8_t>::Write w64 = b64buff.write();
 
-	int strlen = base64_encode((char *)(&w64[0]), (char *)(&r[0]), len);
+	size_t strlen = 0;
+	ERR_FAIL_COND_V(CryptoCore::b64_encode(&w64[0], b64len, &strlen, &r[0], len) != OK, String());
 	w64[strlen] = 0;
 	String ret = (char *)&w64[0];
 
@@ -2486,17 +2488,16 @@ PoolVector<uint8_t> _Marshalls::base64_to_raw(const String &p_str) {
 	int strlen = p_str.length();
 	CharString cstr = p_str.ascii();
 
-	int arr_len;
+	size_t arr_len = 0;
 	PoolVector<uint8_t> buf;
 	{
 		buf.resize(strlen / 4 * 3 + 1);
 		PoolVector<uint8_t>::Write w = buf.write();
 
-		arr_len = base64_decode((char *)(&w[0]), (char *)cstr.get_data(), strlen);
-	};
+		ERR_FAIL_COND_V(CryptoCore::b64_decode(&w[0], buf.size(), &arr_len, (unsigned char *)cstr.get_data(), strlen) != OK, PoolVector<uint8_t>());
+	}
 	buf.resize(arr_len);
 
-	// conversion from PoolVector<uint8_t> to raw array?
 	return buf;
 };
 
@@ -2510,7 +2511,8 @@ String _Marshalls::utf8_to_base64(const String &p_str) {
 	b64buff.resize(b64len);
 	PoolVector<uint8_t>::Write w64 = b64buff.write();
 
-	int strlen = base64_encode((char *)(&w64[0]), (char *)cstr.get_data(), len);
+	size_t strlen = 0;
+	ERR_FAIL_COND_V(CryptoCore::b64_encode(&w64[0], b64len, &strlen, (unsigned char *)cstr.get_data(), len) != OK, String());
 
 	w64[strlen] = 0;
 	String ret = (char *)&w64[0];
@@ -2527,7 +2529,8 @@ String _Marshalls::base64_to_utf8(const String &p_str) {
 	buf.resize(strlen / 4 * 3 + 1 + 1);
 	PoolVector<uint8_t>::Write w = buf.write();
 
-	int len = base64_decode((char *)(&w[0]), (char *)cstr.get_data(), strlen);
+	size_t len = 0;
+	ERR_FAIL_COND_V(CryptoCore::b64_decode(&w[0], buf.size(), &len, (unsigned char *)cstr.get_data(), strlen) != OK, String());
 
 	w[len] = 0;
 	String ret = String::utf8((char *)&w[0]);
diff --git a/core/io/file_access_encrypted.cpp b/core/io/file_access_encrypted.cpp
index 7dea749a43..ccee6aeb15 100644
--- a/core/io/file_access_encrypted.cpp
+++ b/core/io/file_access_encrypted.cpp
@@ -30,13 +30,11 @@
 
 #include "file_access_encrypted.h"
 
+#include "core/math/crypto_core.h"
 #include "core/os/copymem.h"
 #include "core/print_string.h"
 #include "core/variant.h"
 
-#include "thirdparty/misc/aes256.h"
-#include "thirdparty/misc/md5.h"
-
 #include <stdio.h>
 
 #define COMP_MAGIC 0x43454447
@@ -83,25 +81,21 @@ Error FileAccessEncrypted::open_and_parse(FileAccess *p_base, const Vector<uint8
 		uint32_t blen = p_base->get_buffer(data.ptrw(), ds);
 		ERR_FAIL_COND_V(blen != ds, ERR_FILE_CORRUPT);
 
-		aes256_context ctx;
-		aes256_init(&ctx, key.ptrw());
+		CryptoCore::AESContext ctx;
+		ctx.set_decode_key(key.ptrw(), 256);
 
 		for (size_t i = 0; i < ds; i += 16) {
 
-			aes256_decrypt_ecb(&ctx, &data.write[i]);
+			ctx.decrypt_ecb(&data.write[i], &data.write[i]);
 		}
 
-		aes256_done(&ctx);
-
 		data.resize(length);
 
-		MD5_CTX md5;
-		MD5Init(&md5);
-		MD5Update(&md5, (uint8_t *)data.ptr(), data.size());
-		MD5Final(&md5);
+		unsigned char hash[16];
+		ERR_FAIL_COND_V(CryptoCore::md5(data.ptr(), data.size(), hash) != OK, ERR_BUG);
 
 		ERR_EXPLAIN("The MD5 sum of the decrypted file does not match the expected value. It could be that the file is corrupt, or that the provided decryption key is invalid.");
-		ERR_FAIL_COND_V(String::md5(md5.digest) != String::md5(md5d), ERR_FILE_CORRUPT);
+		ERR_FAIL_COND_V(String::md5(hash) != String::md5(md5d), ERR_FILE_CORRUPT);
 
 		file = p_base;
 	}
@@ -140,10 +134,8 @@ void FileAccessEncrypted::close() {
 			len += 16 - (len % 16);
 		}
 
-		MD5_CTX md5;
-		MD5Init(&md5);
-		MD5Update(&md5, (uint8_t *)data.ptr(), data.size());
-		MD5Final(&md5);
+		unsigned char hash[16];
+		ERR_FAIL_COND(CryptoCore::md5(data.ptr(), data.size(), hash) != OK); // Bug?
 
 		compressed.resize(len);
 		zeromem(compressed.ptrw(), len);
@@ -151,20 +143,18 @@ void FileAccessEncrypted::close() {
 			compressed.write[i] = data[i];
 		}
 
-		aes256_context ctx;
-		aes256_init(&ctx, key.ptrw());
+		CryptoCore::AESContext ctx;
+		ctx.set_encode_key(key.ptrw(), 256);
 
 		for (size_t i = 0; i < len; i += 16) {
 
-			aes256_encrypt_ecb(&ctx, &compressed.write[i]);
+			ctx.encrypt_ecb(&compressed.write[i], &compressed.write[i]);
 		}
 
-		aes256_done(&ctx);
-
 		file->store_32(COMP_MAGIC);
 		file->store_32(mode);
 
-		file->store_buffer(md5.digest, 16);
+		file->store_buffer(hash, 16);
 		file->store_64(data.size());
 
 		file->store_buffer(compressed.ptr(), compressed.size());
diff --git a/core/math/SCsub b/core/math/SCsub
index 1c5f954470..4e76efceff 100644
--- a/core/math/SCsub
+++ b/core/math/SCsub
@@ -2,4 +2,37 @@
 
 Import('env')
 
-env.add_source_files(env.core_sources, "*.cpp")
+env_math = env.Clone() # Maybe make one specific for crypto?
+
+is_builtin = env["builtin_mbedtls"]
+has_module = env["module_mbedtls_enabled"]
+
+if is_builtin or not has_module:
+    # Use our headers for builtin or if the module is not going to be compiled.
+    # We decided not to depend on system mbedtls just for these few files that can
+    # be easily extracted.
+    env_math.Prepend(CPPPATH=["#thirdparty/mbedtls/include"])
+
+# MbedTLS core functions (for CryptoCore).
+# If the mbedtls module is compiled we don't need to add the .c files with our
+# custom config since they will be built by the module itself.
+# Only if the module is not enabled, we must compile here the required sources
+# to make a "light" build with only the necessary mbedtls files.
+if not has_module:
+    env_thirdparty = env_math.Clone()
+    env_thirdparty.disable_warnings()
+    # Custom config file
+    env_thirdparty.Append(CPPFLAGS=['-DMBEDTLS_CONFIG_FILE="\\"thirdparty/mbedtls/include/godot_core_mbedtls_config.h\\""'])
+    thirdparty_mbedtls_dir = "#thirdparty/mbedtls/library/"
+    thirdparty_mbedtls_sources = [
+        "aes.c",
+        "base64.c",
+        "md5.c",
+        "sha1.c",
+        "sha256.c",
+        "godot_core_mbedtls_platform.c"
+    ]
+    thirdparty_mbedtls_sources = [thirdparty_mbedtls_dir + file for file in thirdparty_mbedtls_sources]
+    env_thirdparty.add_source_files(env.core_sources, thirdparty_mbedtls_sources)
+
+env_math.add_source_files(env.core_sources, "*.cpp")
diff --git a/core/math/crypto_core.cpp b/core/math/crypto_core.cpp
new file mode 100644
index 0000000000..6449d94db8
--- /dev/null
+++ b/core/math/crypto_core.cpp
@@ -0,0 +1,146 @@
+/*************************************************************************/
+/*  crypto_core.cpp                                                      */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "crypto_core.h"
+
+#include <mbedtls/aes.h>
+#include <mbedtls/base64.h>
+#include <mbedtls/md5.h>
+#include <mbedtls/sha1.h>
+#include <mbedtls/sha256.h>
+
+// MD5
+CryptoCore::MD5Context::MD5Context() {
+	ctx = memalloc(sizeof(mbedtls_md5_context));
+	mbedtls_md5_init((mbedtls_md5_context *)ctx);
+}
+
+CryptoCore::MD5Context::~MD5Context() {
+	mbedtls_md5_free((mbedtls_md5_context *)ctx);
+	memfree((mbedtls_md5_context *)ctx);
+}
+
+Error CryptoCore::MD5Context::start() {
+	int ret = mbedtls_md5_starts_ret((mbedtls_md5_context *)ctx);
+	return ret ? FAILED : OK;
+}
+
+Error CryptoCore::MD5Context::update(uint8_t *p_src, size_t p_len) {
+	int ret = mbedtls_md5_update_ret((mbedtls_md5_context *)ctx, p_src, p_len);
+	return ret ? FAILED : OK;
+}
+
+Error CryptoCore::MD5Context::finish(unsigned char r_hash[16]) {
+	int ret = mbedtls_md5_finish_ret((mbedtls_md5_context *)ctx, r_hash);
+	return ret ? FAILED : OK;
+}
+
+// SHA256
+CryptoCore::SHA256Context::SHA256Context() {
+	ctx = memalloc(sizeof(mbedtls_sha256_context));
+	mbedtls_sha256_init((mbedtls_sha256_context *)ctx);
+}
+
+CryptoCore::SHA256Context::~SHA256Context() {
+	mbedtls_sha256_free((mbedtls_sha256_context *)ctx);
+	memfree((mbedtls_sha256_context *)ctx);
+}
+
+Error CryptoCore::SHA256Context::start() {
+	int ret = mbedtls_sha256_starts_ret((mbedtls_sha256_context *)ctx, 0);
+	return ret ? FAILED : OK;
+}
+
+Error CryptoCore::SHA256Context::update(uint8_t *p_src, size_t p_len) {
+	int ret = mbedtls_sha256_update_ret((mbedtls_sha256_context *)ctx, p_src, p_len);
+	return ret ? FAILED : OK;
+}
+
+Error CryptoCore::SHA256Context::finish(unsigned char r_hash[16]) {
+	int ret = mbedtls_sha256_finish_ret((mbedtls_sha256_context *)ctx, r_hash);
+	return ret ? FAILED : OK;
+}
+
+// AES256
+CryptoCore::AESContext::AESContext() {
+	ctx = memalloc(sizeof(mbedtls_aes_context));
+	mbedtls_aes_init((mbedtls_aes_context *)ctx);
+}
+
+CryptoCore::AESContext::~AESContext() {
+	mbedtls_aes_free((mbedtls_aes_context *)ctx);
+	memfree((mbedtls_aes_context *)ctx);
+}
+
+Error CryptoCore::AESContext::set_encode_key(const uint8_t *p_key, size_t p_bits) {
+	int ret = mbedtls_aes_setkey_enc((mbedtls_aes_context *)ctx, p_key, p_bits);
+	return ret ? FAILED : OK;
+}
+
+Error CryptoCore::AESContext::set_decode_key(const uint8_t *p_key, size_t p_bits) {
+	int ret = mbedtls_aes_setkey_dec((mbedtls_aes_context *)ctx, p_key, p_bits);
+	return ret ? FAILED : OK;
+}
+
+Error CryptoCore::AESContext::encrypt_ecb(const uint8_t p_src[16], uint8_t r_dst[16]) {
+	int ret = mbedtls_aes_crypt_ecb((mbedtls_aes_context *)ctx, MBEDTLS_AES_ENCRYPT, p_src, r_dst);
+	return ret ? FAILED : OK;
+}
+
+Error CryptoCore::AESContext::decrypt_ecb(const uint8_t p_src[16], uint8_t r_dst[16]) {
+	int ret = mbedtls_aes_crypt_ecb((mbedtls_aes_context *)ctx, MBEDTLS_AES_DECRYPT, p_src, r_dst);
+	return ret ? FAILED : OK;
+}
+
+// CryptoCore
+Error CryptoCore::b64_encode(uint8_t *r_dst, int p_dst_len, size_t *r_len, const uint8_t *p_src, int p_src_len) {
+	int ret = mbedtls_base64_encode(r_dst, p_dst_len, r_len, p_src, p_src_len);
+	return ret ? FAILED : OK;
+}
+
+Error CryptoCore::b64_decode(uint8_t *r_dst, int p_dst_len, size_t *r_len, const uint8_t *p_src, int p_src_len) {
+	int ret = mbedtls_base64_decode(r_dst, p_dst_len, r_len, p_src, p_src_len);
+	return ret ? FAILED : OK;
+}
+
+Error CryptoCore::md5(const uint8_t *p_src, int p_src_len, unsigned char r_hash[16]) {
+	int ret = mbedtls_md5_ret(p_src, p_src_len, r_hash);
+	return ret ? FAILED : OK;
+}
+
+Error CryptoCore::sha1(const uint8_t *p_src, int p_src_len, unsigned char r_hash[20]) {
+	int ret = mbedtls_sha1_ret(p_src, p_src_len, r_hash);
+	return ret ? FAILED : OK;
+}
+
+Error CryptoCore::sha256(const uint8_t *p_src, int p_src_len, unsigned char r_hash[32]) {
+	int ret = mbedtls_sha256_ret(p_src, p_src_len, r_hash, 0);
+	return ret ? FAILED : OK;
+}
diff --git a/core/math/crypto_core.h b/core/math/crypto_core.h
new file mode 100644
index 0000000000..1cb3c86e18
--- /dev/null
+++ b/core/math/crypto_core.h
@@ -0,0 +1,89 @@
+/*************************************************************************/
+/*  crypto_core.h                                                        */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef CRYPTO_CORE_H
+#define CRYPTO_CORE_H
+
+#include "core/reference.h"
+
+class CryptoCore {
+
+public:
+	class MD5Context {
+
+	private:
+		void *ctx; // To include, or not to include...
+
+	public:
+		MD5Context();
+		~MD5Context();
+
+		Error start();
+		Error update(uint8_t *p_src, size_t p_len);
+		Error finish(unsigned char r_hash[16]);
+	};
+
+	class SHA256Context {
+
+	private:
+		void *ctx; // To include, or not to include...
+
+	public:
+		SHA256Context();
+		~SHA256Context();
+
+		Error start();
+		Error update(uint8_t *p_src, size_t p_len);
+		Error finish(unsigned char r_hash[16]);
+	};
+
+	class AESContext {
+
+	private:
+		void *ctx; // To include, or not to include...
+
+	public:
+		AESContext();
+		~AESContext();
+
+		Error set_encode_key(const uint8_t *p_key, size_t p_bits);
+		Error set_decode_key(const uint8_t *p_key, size_t p_bits);
+		Error encrypt_ecb(const uint8_t p_src[16], uint8_t r_dst[16]);
+		Error decrypt_ecb(const uint8_t p_src[16], uint8_t r_dst[16]);
+	};
+
+	static Error b64_encode(uint8_t *r_dst, int p_dst_len, size_t *r_len, const uint8_t *p_src, int p_src_len);
+	static Error b64_decode(uint8_t *r_dst, int p_dst_len, size_t *r_len, const uint8_t *p_src, int p_src_len);
+
+	static Error md5(const uint8_t *p_src, int p_src_len, unsigned char r_hash[16]);
+	static Error sha1(const uint8_t *p_src, int p_src_len, unsigned char r_hash[20]);
+	static Error sha256(const uint8_t *p_src, int p_src_len, unsigned char r_hash[32]);
+};
+#endif // CRYPTO_CORE_H
diff --git a/core/os/file_access.cpp b/core/os/file_access.cpp
index b5580b5c6e..7509050b2b 100644
--- a/core/os/file_access.cpp
+++ b/core/os/file_access.cpp
@@ -32,12 +32,10 @@
 
 #include "core/io/file_access_pack.h"
 #include "core/io/marshalls.h"
+#include "core/math/crypto_core.h"
 #include "core/os/os.h"
 #include "core/project_settings.h"
 
-#include "thirdparty/misc/md5.h"
-#include "thirdparty/misc/sha256.h"
-
 FileAccess::CreateFunc FileAccess::create_func[ACCESS_MAX] = { 0, 0 };
 
 FileAccess::FileCloseFailNotify FileAccess::close_fail_notify = NULL;
@@ -637,8 +635,8 @@ String FileAccess::get_md5(const String &p_file) {
 	if (!f)
 		return String();
 
-	MD5_CTX md5;
-	MD5Init(&md5);
+	CryptoCore::MD5Context ctx;
+	ctx.start();
 
 	unsigned char step[32768];
 
@@ -647,24 +645,24 @@ String FileAccess::get_md5(const String &p_file) {
 		int br = f->get_buffer(step, 32768);
 		if (br > 0) {
 
-			MD5Update(&md5, step, br);
+			ctx.update(step, br);
 		}
 		if (br < 4096)
 			break;
 	}
 
-	MD5Final(&md5);
-
-	String ret = String::md5(md5.digest);
+	unsigned char hash[16];
+	ctx.finish(hash);
 
 	memdelete(f);
-	return ret;
+
+	return String::md5(hash);
 }
 
 String FileAccess::get_multiple_md5(const Vector<String> &p_file) {
 
-	MD5_CTX md5;
-	MD5Init(&md5);
+	CryptoCore::MD5Context ctx;
+	ctx.start();
 
 	for (int i = 0; i < p_file.size(); i++) {
 		FileAccess *f = FileAccess::open(p_file[i], READ);
@@ -677,7 +675,7 @@ String FileAccess::get_multiple_md5(const Vector<String> &p_file) {
 			int br = f->get_buffer(step, 32768);
 			if (br > 0) {
 
-				MD5Update(&md5, step, br);
+				ctx.update(step, br);
 			}
 			if (br < 4096)
 				break;
@@ -685,11 +683,10 @@ String FileAccess::get_multiple_md5(const Vector<String> &p_file) {
 		memdelete(f);
 	}
 
-	MD5Final(&md5);
+	unsigned char hash[16];
+	ctx.finish(hash);
 
-	String ret = String::md5(md5.digest);
-
-	return ret;
+	return String::md5(hash);
 }
 
 String FileAccess::get_sha256(const String &p_file) {
@@ -698,8 +695,8 @@ String FileAccess::get_sha256(const String &p_file) {
 	if (!f)
 		return String();
 
-	sha256_context sha256;
-	sha256_init(&sha256);
+	CryptoCore::SHA256Context ctx;
+	ctx.start();
 
 	unsigned char step[32768];
 
@@ -708,15 +705,14 @@ String FileAccess::get_sha256(const String &p_file) {
 		int br = f->get_buffer(step, 32768);
 		if (br > 0) {
 
-			sha256_hash(&sha256, step, br);
+			ctx.update(step, br);
 		}
 		if (br < 4096)
 			break;
 	}
 
 	unsigned char hash[32];
-
-	sha256_done(&sha256, hash);
+	ctx.finish(hash);
 
 	memdelete(f);
 	return String::hex_encode_buffer(hash, 32);
diff --git a/core/ustring.cpp b/core/ustring.cpp
index 18c48b4dad..2b312191e2 100644
--- a/core/ustring.cpp
+++ b/core/ustring.cpp
@@ -31,6 +31,7 @@
 #include "ustring.h"
 
 #include "core/color.h"
+#include "core/math/crypto_core.h"
 #include "core/math/math_funcs.h"
 #include "core/os/memory.h"
 #include "core/print_string.h"
@@ -38,9 +39,6 @@
 #include "core/ucaps.h"
 #include "core/variant.h"
 
-#include "thirdparty/misc/md5.h"
-#include "thirdparty/misc/sha256.h"
-
 #include <wchar.h>
 
 #ifndef NO_USE_STDLIB
@@ -2254,54 +2252,42 @@ uint64_t String::hash64() const {
 String String::md5_text() const {
 
 	CharString cs = utf8();
-	MD5_CTX ctx;
-	MD5Init(&ctx);
-	MD5Update(&ctx, (unsigned char *)cs.ptr(), cs.length());
-	MD5Final(&ctx);
-	return String::md5(ctx.digest);
+	unsigned char hash[16];
+	CryptoCore::md5((unsigned char *)cs.ptr(), cs.length(), hash);
+	return String::hex_encode_buffer(hash, 16);
 }
 
 String String::sha256_text() const {
 	CharString cs = utf8();
 	unsigned char hash[32];
-	sha256_context ctx;
-	sha256_init(&ctx);
-	sha256_hash(&ctx, (unsigned char *)cs.ptr(), cs.length());
-	sha256_done(&ctx, hash);
+	CryptoCore::sha256((unsigned char *)cs.ptr(), cs.length(), hash);
 	return String::hex_encode_buffer(hash, 32);
 }
 
 Vector<uint8_t> String::md5_buffer() const {
 
 	CharString cs = utf8();
-	MD5_CTX ctx;
-	MD5Init(&ctx);
-	MD5Update(&ctx, (unsigned char *)cs.ptr(), cs.length());
-	MD5Final(&ctx);
+	unsigned char hash[16];
+	CryptoCore::md5((unsigned char *)cs.ptr(), cs.length(), hash);
 
 	Vector<uint8_t> ret;
 	ret.resize(16);
 	for (int i = 0; i < 16; i++) {
-		ret.write[i] = ctx.digest[i];
-	};
-
+		ret.write[i] = hash[i];
+	}
 	return ret;
 };
 
 Vector<uint8_t> String::sha256_buffer() const {
 	CharString cs = utf8();
 	unsigned char hash[32];
-	sha256_context ctx;
-	sha256_init(&ctx);
-	sha256_hash(&ctx, (unsigned char *)cs.ptr(), cs.length());
-	sha256_done(&ctx, hash);
+	CryptoCore::sha256((unsigned char *)cs.ptr(), cs.length(), hash);
 
 	Vector<uint8_t> ret;
 	ret.resize(32);
 	for (int i = 0; i < 32; i++) {
 		ret.write[i] = hash[i];
 	}
-
 	return ret;
 }
 
diff --git a/core/variant_call.cpp b/core/variant_call.cpp
index dc28f1ca02..811008e7c8 100644
--- a/core/variant_call.cpp
+++ b/core/variant_call.cpp
@@ -33,10 +33,10 @@
 #include "core/color_names.inc"
 #include "core/core_string_names.h"
 #include "core/io/compression.h"
+#include "core/math/crypto_core.h"
 #include "core/object.h"
 #include "core/os/os.h"
 #include "core/script_language.h"
-#include "thirdparty/misc/sha256.h"
 
 typedef void (*VariantFunc)(Variant &r_ret, Variant &p_self, const Variant **p_args);
 typedef void (*VariantConstructFunc)(Variant &r_ret, const Variant **p_args);
@@ -598,10 +598,7 @@ struct _VariantCall {
 		PoolByteArray::Read r = ba->read();
 		String s;
 		unsigned char hash[32];
-		sha256_context sha256;
-		sha256_init(&sha256);
-		sha256_hash(&sha256, (unsigned char *)r.ptr(), ba->size());
-		sha256_done(&sha256, hash);
+		CryptoCore::sha256((unsigned char *)r.ptr(), ba->size(), hash);
 		s = String::hex_encode_buffer(hash, 32);
 		r_ret = s;
 	}
diff --git a/editor/editor_export.cpp b/editor/editor_export.cpp
index bebd5b2412..9c10c05b59 100644
--- a/editor/editor_export.cpp
+++ b/editor/editor_export.cpp
@@ -34,6 +34,7 @@
 #include "core/io/resource_loader.h"
 #include "core/io/resource_saver.h"
 #include "core/io/zip_io.h"
+#include "core/math/crypto_core.h"
 #include "core/os/file_access.h"
 #include "core/project_settings.h"
 #include "core/script_language.h"
@@ -43,7 +44,6 @@
 #include "editor_node.h"
 #include "editor_settings.h"
 #include "scene/resources/resource_format_text.h"
-#include "thirdparty/misc/md5.h"
 
 static int _get_pad(int p_alignment, int p_n) {
 
@@ -323,13 +323,11 @@ Error EditorExportPlatform::_save_pack_file(void *p_userdata, const String &p_pa
 	}
 
 	{
-		MD5_CTX ctx;
-		MD5Init(&ctx);
-		MD5Update(&ctx, (unsigned char *)p_data.ptr(), p_data.size());
-		MD5Final(&ctx);
+		unsigned char hash[16];
+		CryptoCore::md5(p_data.ptr(), p_data.size(), hash);
 		sd.md5.resize(16);
 		for (int i = 0; i < 16; i++) {
-			sd.md5.write[i] = ctx.digest[i];
+			sd.md5.write[i] = hash[i];
 		}
 	}
 
diff --git a/editor/import/editor_scene_importer_gltf.cpp b/editor/import/editor_scene_importer_gltf.cpp
index 2bfc77325f..bc507e91b2 100644
--- a/editor/import/editor_scene_importer_gltf.cpp
+++ b/editor/import/editor_scene_importer_gltf.cpp
@@ -30,6 +30,7 @@
 
 #include "editor_scene_importer_gltf.h"
 #include "core/io/json.h"
+#include "core/math/crypto_core.h"
 #include "core/math/math_defs.h"
 #include "core/os/file_access.h"
 #include "core/os/os.h"
@@ -37,7 +38,6 @@
 #include "scene/3d/mesh_instance.h"
 #include "scene/animation/animation_player.h"
 #include "scene/resources/surface_tool.h"
-#include "thirdparty/misc/base64.h"
 
 uint32_t EditorSceneImporterGLTF::get_import_flags() const {
 
@@ -279,7 +279,8 @@ static Vector<uint8_t> _parse_base64_uri(const String &uri) {
 	Vector<uint8_t> buf;
 	buf.resize(strlen / 4 * 3 + 1 + 1);
 
-	int len = base64_decode((char *)buf.ptr(), (char *)substr.get_data(), strlen);
+	size_t len = 0;
+	ERR_FAIL_COND_V(CryptoCore::b64_decode(buf.ptrw(), buf.size(), &len, (unsigned char *)substr.get_data(), strlen) != OK, Vector<uint8_t>());
 
 	buf.resize(len);
 
diff --git a/modules/mbedtls/stream_peer_mbed_tls.cpp b/modules/mbedtls/stream_peer_mbed_tls.cpp
index 3541eff25a..4bb7557150 100755
--- a/modules/mbedtls/stream_peer_mbed_tls.cpp
+++ b/modules/mbedtls/stream_peer_mbed_tls.cpp
@@ -33,8 +33,6 @@
 #include "core/io/stream_peer_tcp.h"
 #include "core/os/file_access.h"
 
-#include <mbedtls/platform_util.h>
-
 static void my_debug(void *ctx, int level,
 		const char *file, int line,
 		const char *str) {
diff --git a/modules/mbedtls/stream_peer_mbed_tls.h b/modules/mbedtls/stream_peer_mbed_tls.h
index 3ddbea3ce4..ab87b779c1 100755
--- a/modules/mbedtls/stream_peer_mbed_tls.h
+++ b/modules/mbedtls/stream_peer_mbed_tls.h
@@ -37,7 +37,6 @@
 #include <mbedtls/ctr_drbg.h>
 #include <mbedtls/debug.h>
 #include <mbedtls/entropy.h>
-#include <mbedtls/net.h>
 #include <mbedtls/ssl.h>
 
 #include <stdio.h>
diff --git a/platform/uwp/export/export.cpp b/platform/uwp/export/export.cpp
index ec43a4c26f..abb7b391d3 100644
--- a/platform/uwp/export/export.cpp
+++ b/platform/uwp/export/export.cpp
@@ -32,6 +32,7 @@
 #include "core/bind/core_bind.h"
 #include "core/io/marshalls.h"
 #include "core/io/zip_io.h"
+#include "core/math/crypto_core.h"
 #include "core/object.h"
 #include "core/os/file_access.h"
 #include "core/project_settings.h"
@@ -42,8 +43,6 @@
 
 #include "thirdparty/minizip/unzip.h"
 #include "thirdparty/minizip/zip.h"
-#include "thirdparty/misc/base64.h"
-#include "thirdparty/misc/sha256.h"
 
 #include <zlib.h>
 
@@ -198,15 +197,12 @@ public:
 
 String AppxPackager::hash_block(const uint8_t *p_block_data, size_t p_block_len) {
 
-	char hash[32];
+	unsigned char hash[32];
 	char base64[45];
 
-	sha256_context ctx;
-	sha256_init(&ctx);
-	sha256_hash(&ctx, (uint8_t *)p_block_data, p_block_len);
-	sha256_done(&ctx, (uint8_t *)hash);
-
-	base64_encode(base64, hash, 32);
+	CryptoCore::sha256(p_block_data, p_block_len, hash);
+	size_t len = 0;
+	CryptoCore::b64_encode((unsigned char *)base64, 45, &len, (unsigned char *)hash, 32);
 	base64[44] = '\0';
 
 	return String(base64);
diff --git a/thirdparty/README.md b/thirdparty/README.md
index b003ae6e8a..9738716221 100644
--- a/thirdparty/README.md
+++ b/thirdparty/README.md
@@ -303,6 +303,8 @@ File extracted from upstream release tarball `mbedtls-2.16.0-apache.tgz`:
 - Applied the patch in `thirdparty/mbedtls/padlock.diff`. This disables VIA
   padlock support which defines a symbol `unsupported` which clashes with
   a symbol in libwebsockets.
+- Added 2 files `godot_core_mbedtls_platform.{c,h}` providing configuration
+  for light bundling with core.
 
 
 ## miniupnpc
@@ -340,15 +342,7 @@ Collection of single-file libraries used in Godot components.
 
 ### core
 
-- `aes256.{cpp,h}`
-  * Upstream: http://www.literatecode.com/aes256
-  * Version: latest, as of April 2017
-  * License: ISC
-- `base64.{c,h}`
-  * Upstream: http://episec.com/people/edelkind/c.html
-  * Version: latest, as of April 2017
-  * License: Public Domain
- - `clipper.{cpp,hpp}`
+- `clipper.{cpp,hpp}`
   * Upstream: https://sourceforge.net/projects/polyclipping
   * Version: 6.4.2 + Godot changes (added optional exceptions handling)
   * License: BSL-1.0
@@ -360,10 +354,6 @@ Collection of single-file libraries used in Godot components.
   * Upstream: https://github.com/brunexgeek/hqx
   * Version: TBD, file structure differs
   * License: Apache 2.0
-- `md5.{cpp,h}`
-  * Upstream: http://www.efgh.com/software/md5.htm
-  * Version: TBD, might not be latest from above URL
-  * License: RSA Message-Digest License
 - `open-simplex-noise.{c,h}`
   * Upstream: https://github.com/smcameron/open-simplex-noise-in-c
   * Version: git (0d555e7, 2015)
@@ -372,10 +362,6 @@ Collection of single-file libraries used in Godot components.
   * Upstream: http://www.pcg-random.org
   * Version: minimal C implementation, http://www.pcg-random.org/download.html
   * License: Apache 2.0
-- `sha256.{c,h}`
-  * Upstream: https://github.com/ilvn/SHA256
-  * Version: git (35ff823, 2015)
-  * License: ISC
 - `smaz.{c,h}`
   * Upstream: https://github.com/antirez/smaz
   * Version: git (150e125, 2009)
diff --git a/thirdparty/mbedtls/include/godot_core_mbedtls_config.h b/thirdparty/mbedtls/include/godot_core_mbedtls_config.h
new file mode 100644
index 0000000000..0e90a98886
--- /dev/null
+++ b/thirdparty/mbedtls/include/godot_core_mbedtls_config.h
@@ -0,0 +1,13 @@
+// For AES
+#define MBEDTLS_CIPHER_MODE_CBC
+#define MBEDTLS_CIPHER_MODE_CFB
+#define MBEDTLS_CIPHER_MODE_CTR
+#define MBEDTLS_CIPHER_MODE_OFB
+#define MBEDTLS_CIPHER_MODE_XTS
+
+#define MBEDTLS_AES_C
+#define MBEDTLS_BASE64_C
+#define MBEDTLS_MD5_C
+#define MBEDTLS_SHA1_C
+#define MBEDTLS_SHA256_C
+#define MBEDTLS_PLATFORM_ZEROIZE_ALT
diff --git a/thirdparty/mbedtls/library/godot_core_mbedtls_platform.c b/thirdparty/mbedtls/library/godot_core_mbedtls_platform.c
new file mode 100644
index 0000000000..9018726072
--- /dev/null
+++ b/thirdparty/mbedtls/library/godot_core_mbedtls_platform.c
@@ -0,0 +1,18 @@
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <stddef.h>
+
+#ifdef MBEDTLS_PLATFORM_ZEROIZE_ALT
+static void *(*const volatile memset_func)(void *, int, size_t) = memset;
+
+void mbedtls_platform_zeroize(void *buf, size_t len) {
+    memset_func( buf, 0, len );
+}
+#endif
+
diff --git a/thirdparty/misc/aes256.cpp b/thirdparty/misc/aes256.cpp
deleted file mode 100644
index dc271928b4..0000000000
--- a/thirdparty/misc/aes256.cpp
+++ /dev/null
@@ -1,397 +0,0 @@
-/*
-*   Byte-oriented AES-256 implementation.
-*   All lookup tables replaced with 'on the fly' calculations.
-*
-*   Copyright (c) 2007-2011 Ilya O. Levin, http://www.literatecode.com
-*   Other contributors: Hal Finney
-*
-*   Permission to use, copy, modify, and distribute this software for any
-*   purpose with or without fee is hereby granted, provided that the above
-*   copyright notice and this permission notice appear in all copies.
-*
-*   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-*   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-*   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-*   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-*   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-*   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-*   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-#include "aes256.h"
-
-#define FD(x)  (((x) >> 1) ^ (((x) & 1) ? 0x8d : 0))
-
-#define BACK_TO_TABLES
-
-static uint8_t rj_xtime(uint8_t);
-static void aes_subBytes(uint8_t *);
-static void aes_subBytes_inv(uint8_t *);
-static void aes_addRoundKey(uint8_t *, uint8_t *);
-static void aes_addRoundKey_cpy(uint8_t *, uint8_t *, uint8_t *);
-static void aes_shiftRows(uint8_t *);
-static void aes_shiftRows_inv(uint8_t *);
-static void aes_mixColumns(uint8_t *);
-static void aes_mixColumns_inv(uint8_t *);
-static void aes_expandEncKey(uint8_t *, uint8_t *);
-static void aes_expandDecKey(uint8_t *, uint8_t *);
-#ifndef BACK_TO_TABLES
-static uint8_t gf_alog(uint8_t);
-static uint8_t gf_log(uint8_t);
-static uint8_t gf_mulinv(uint8_t);
-static uint8_t rj_sbox(uint8_t);
-static uint8_t rj_sbox_inv(uint8_t);
-#endif
-
-#ifdef BACK_TO_TABLES
-
-static const uint8_t sbox[256] = {
-    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
-    0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
-    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
-    0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
-    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc,
-    0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
-    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a,
-    0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
-    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
-    0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
-    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b,
-    0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
-    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85,
-    0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
-    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
-    0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
-    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17,
-    0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
-    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88,
-    0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
-    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
-    0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
-    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9,
-    0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
-    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6,
-    0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
-    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
-    0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
-    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
-    0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
-    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
-    0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
-};
-static const uint8_t sboxinv[256] = {
-    0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38,
-    0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
-    0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87,
-    0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
-    0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d,
-    0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
-    0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2,
-    0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
-    0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16,
-    0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
-    0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda,
-    0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
-    0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a,
-    0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
-    0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02,
-    0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
-    0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea,
-    0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
-    0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85,
-    0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
-    0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89,
-    0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
-    0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20,
-    0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
-    0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31,
-    0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
-    0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d,
-    0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
-    0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0,
-    0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
-    0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26,
-    0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
-};
-
-#define rj_sbox(x)     sbox[(x)]
-#define rj_sbox_inv(x) sboxinv[(x)]
-
-#else /* tableless subroutines */
-
-/* -------------------------------------------------------------------------- */
-static uint8_t gf_alog(uint8_t x) // calculate anti-logarithm gen 3
-{
-    uint8_t y = 1, i;
-
-    for (i = 0; i < x; i++) y ^= rj_xtime(y);
-
-    return y;
-} /* gf_alog */
-
-/* -------------------------------------------------------------------------- */
-static uint8_t gf_log(uint8_t x) // calculate logarithm gen 3
-{
-    uint8_t y, i = 0;
-
-    if (x)
-        for (i = 1, y = 1; i > 0; i++ )
-        {
-            y ^= rj_xtime(y);
-            if (y == x) break;
-        }
-
-    return i;
-} /* gf_log */
-
-
-/* -------------------------------------------------------------------------- */
-static uint8_t gf_mulinv(uint8_t x) // calculate multiplicative inverse
-{
-    return (x) ? gf_alog(255 - gf_log(x)) : 0;
-} /* gf_mulinv */
-
-/* -------------------------------------------------------------------------- */
-static uint8_t rj_sbox(uint8_t x)
-{
-    uint8_t y, sb;
-
-    sb = y = gf_mulinv(x);
-    y = (uint8_t)(y << 1) | (y >> 7), sb ^= y;
-    y = (uint8_t)(y << 1) | (y >> 7), sb ^= y;
-    y = (uint8_t)(y << 1) | (y >> 7), sb ^= y;
-    y = (uint8_t)(y << 1) | (y >> 7), sb ^= y;
-
-    return (sb ^ 0x63);
-} /* rj_sbox */
-
-/* -------------------------------------------------------------------------- */
-static uint8_t rj_sbox_inv(uint8_t x)
-{
-    uint8_t y, sb;
-
-    y = x ^ 0x63;
-    sb = y = (uint8_t)(y << 1) | (y >> 7);
-    y = (uint8_t)(y << 2) | (y >> 6);
-    sb ^= y;
-    y = (uint8_t)(y << 3) | (y >> 5);
-    sb ^= y;
-
-    return gf_mulinv(sb);
-} /* rj_sbox_inv */
-
-#endif
-
-/* -------------------------------------------------------------------------- */
-static uint8_t rj_xtime(uint8_t x)
-{
-    uint8_t y = (uint8_t)(x << 1);
-    return (x & 0x80) ? (y ^ 0x1b) : y;
-} /* rj_xtime */
-
-/* -------------------------------------------------------------------------- */
-static void aes_subBytes(uint8_t *buf)
-{
-    register uint8_t i = 16;
-
-    while (i--) buf[i] = rj_sbox(buf[i]);
-} /* aes_subBytes */
-
-/* -------------------------------------------------------------------------- */
-static void aes_subBytes_inv(uint8_t *buf)
-{
-    register uint8_t i = 16;
-
-    while (i--) buf[i] = rj_sbox_inv(buf[i]);
-} /* aes_subBytes_inv */
-
-/* -------------------------------------------------------------------------- */
-static void aes_addRoundKey(uint8_t *buf, uint8_t *key)
-{
-    register uint8_t i = 16;
-
-    while (i--) buf[i] ^= key[i];
-} /* aes_addRoundKey */
-
-/* -------------------------------------------------------------------------- */
-static void aes_addRoundKey_cpy(uint8_t *buf, uint8_t *key, uint8_t *cpk)
-{
-    register uint8_t i = 16;
-
-    while (i--)  buf[i] ^= (cpk[i] = key[i]), cpk[16 + i] = key[16 + i];
-} /* aes_addRoundKey_cpy */
-
-
-/* -------------------------------------------------------------------------- */
-static void aes_shiftRows(uint8_t *buf)
-{
-    register uint8_t i, j; /* to make it potentially parallelable :) */
-
-    i = buf[1], buf[1] = buf[5], buf[5] = buf[9], buf[9] = buf[13], buf[13] = i;
-    i = buf[10], buf[10] = buf[2], buf[2] = i;
-    j = buf[3], buf[3] = buf[15], buf[15] = buf[11], buf[11] = buf[7], buf[7] = j;
-    j = buf[14], buf[14] = buf[6], buf[6]  = j;
-
-} /* aes_shiftRows */
-
-/* -------------------------------------------------------------------------- */
-static void aes_shiftRows_inv(uint8_t *buf)
-{
-    register uint8_t i, j; /* same as above :) */
-
-    i = buf[1], buf[1] = buf[13], buf[13] = buf[9], buf[9] = buf[5], buf[5] = i;
-    i = buf[2], buf[2] = buf[10], buf[10] = i;
-    j = buf[3], buf[3] = buf[7], buf[7] = buf[11], buf[11] = buf[15], buf[15] = j;
-    j = buf[6], buf[6] = buf[14], buf[14] = j;
-
-} /* aes_shiftRows_inv */
-
-/* -------------------------------------------------------------------------- */
-static void aes_mixColumns(uint8_t *buf)
-{
-    register uint8_t i, a, b, c, d, e;
-
-    for (i = 0; i < 16; i += 4)
-    {
-        a = buf[i];
-        b = buf[i + 1];
-        c = buf[i + 2];
-        d = buf[i + 3];
-        e = a ^ b ^ c ^ d;
-        buf[i] ^= e ^ rj_xtime(a ^ b);
-        buf[i + 1] ^= e ^ rj_xtime(b ^ c);
-        buf[i + 2] ^= e ^ rj_xtime(c ^ d);
-        buf[i + 3] ^= e ^ rj_xtime(d ^ a);
-    }
-} /* aes_mixColumns */
-
-/* -------------------------------------------------------------------------- */
-void aes_mixColumns_inv(uint8_t *buf)
-{
-    register uint8_t i, a, b, c, d, e, x, y, z;
-
-    for (i = 0; i < 16; i += 4)
-    {
-        a = buf[i];
-        b = buf[i + 1];
-        c = buf[i + 2];
-        d = buf[i + 3];
-        e = a ^ b ^ c ^ d;
-        z = rj_xtime(e);
-        x = e ^ rj_xtime(rj_xtime(z ^ a ^ c));
-        y = e ^ rj_xtime(rj_xtime(z ^ b ^ d));
-        buf[i] ^= x ^ rj_xtime(a ^ b);
-        buf[i + 1] ^= y ^ rj_xtime(b ^ c);
-        buf[i + 2] ^= x ^ rj_xtime(c ^ d);
-        buf[i + 3] ^= y ^ rj_xtime(d ^ a);
-    }
-} /* aes_mixColumns_inv */
-
-/* -------------------------------------------------------------------------- */
-static void aes_expandEncKey(uint8_t *k, uint8_t *rc)
-{
-    register uint8_t i;
-
-    k[0] ^= rj_sbox(k[29]) ^ (*rc);
-    k[1] ^= rj_sbox(k[30]);
-    k[2] ^= rj_sbox(k[31]);
-    k[3] ^= rj_sbox(k[28]);
-    *rc = rj_xtime( *rc);
-
-    for(i = 4; i < 16; i += 4)  k[i] ^= k[i - 4],   k[i + 1] ^= k[i - 3],
-                                            k[i + 2] ^= k[i - 2], k[i + 3] ^= k[i - 1];
-    k[16] ^= rj_sbox(k[12]);
-    k[17] ^= rj_sbox(k[13]);
-    k[18] ^= rj_sbox(k[14]);
-    k[19] ^= rj_sbox(k[15]);
-
-    for(i = 20; i < 32; i += 4) k[i] ^= k[i - 4],   k[i + 1] ^= k[i - 3],
-                                            k[i + 2] ^= k[i - 2], k[i + 3] ^= k[i - 1];
-
-} /* aes_expandEncKey */
-
-/* -------------------------------------------------------------------------- */
-void aes_expandDecKey(uint8_t *k, uint8_t *rc)
-{
-    uint8_t i;
-
-    for(i = 28; i > 16; i -= 4) k[i + 0] ^= k[i - 4], k[i + 1] ^= k[i - 3],
-                                                k[i + 2] ^= k[i - 2], k[i + 3] ^= k[i - 1];
-
-    k[16] ^= rj_sbox(k[12]);
-    k[17] ^= rj_sbox(k[13]);
-    k[18] ^= rj_sbox(k[14]);
-    k[19] ^= rj_sbox(k[15]);
-
-    for(i = 12; i > 0; i -= 4)  k[i + 0] ^= k[i - 4], k[i + 1] ^= k[i - 3],
-                                                k[i + 2] ^= k[i - 2], k[i + 3] ^= k[i - 1];
-
-    *rc = FD(*rc);
-    k[0] ^= rj_sbox(k[29]) ^ (*rc);
-    k[1] ^= rj_sbox(k[30]);
-    k[2] ^= rj_sbox(k[31]);
-    k[3] ^= rj_sbox(k[28]);
-} /* aes_expandDecKey */
-
-
-/* -------------------------------------------------------------------------- */
-void aes256_init(aes256_context *ctx, uint8_t *k)
-{
-    uint8_t rcon = 1;
-    register uint8_t i;
-
-    for (i = 0; i < sizeof(ctx->key); i++) ctx->enckey[i] = ctx->deckey[i] = k[i];
-    for (i = 8; --i;) aes_expandEncKey(ctx->deckey, &rcon);
-} /* aes256_init */
-
-/* -------------------------------------------------------------------------- */
-void aes256_done(aes256_context *ctx)
-{
-    register uint8_t i;
-
-    for (i = 0; i < sizeof(ctx->key); i++)
-        ctx->key[i] = ctx->enckey[i] = ctx->deckey[i] = 0;
-} /* aes256_done */
-
-/* -------------------------------------------------------------------------- */
-void aes256_encrypt_ecb(aes256_context *ctx, uint8_t *buf)
-{
-    uint8_t i, rcon;
-
-    aes_addRoundKey_cpy(buf, ctx->enckey, ctx->key);
-    for(i = 1, rcon = 1; i < 14; ++i)
-    {
-        aes_subBytes(buf);
-        aes_shiftRows(buf);
-        aes_mixColumns(buf);
-        if( i & 1 ) aes_addRoundKey( buf, &ctx->key[16]);
-        else aes_expandEncKey(ctx->key, &rcon), aes_addRoundKey(buf, ctx->key);
-    }
-    aes_subBytes(buf);
-    aes_shiftRows(buf);
-    aes_expandEncKey(ctx->key, &rcon);
-    aes_addRoundKey(buf, ctx->key);
-} /* aes256_encrypt */
-
-/* -------------------------------------------------------------------------- */
-void aes256_decrypt_ecb(aes256_context *ctx, uint8_t *buf)
-{
-    uint8_t i, rcon;
-
-    aes_addRoundKey_cpy(buf, ctx->deckey, ctx->key);
-    aes_shiftRows_inv(buf);
-    aes_subBytes_inv(buf);
-
-    for (i = 14, rcon = 0x80; --i;)
-    {
-        if( ( i & 1 ) )
-        {
-            aes_expandDecKey(ctx->key, &rcon);
-            aes_addRoundKey(buf, &ctx->key[16]);
-        }
-        else aes_addRoundKey(buf, ctx->key);
-        aes_mixColumns_inv(buf);
-        aes_shiftRows_inv(buf);
-        aes_subBytes_inv(buf);
-    }
-    aes_addRoundKey( buf, ctx->key);
-} /* aes256_decrypt */
diff --git a/thirdparty/misc/aes256.h b/thirdparty/misc/aes256.h
deleted file mode 100644
index 150a0670f5..0000000000
--- a/thirdparty/misc/aes256.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-*   Byte-oriented AES-256 implementation.
-*   All lookup tables replaced with 'on the fly' calculations.
-*
-*   Copyright (c) 2007-2009 Ilya O. Levin, http://www.literatecode.com
-*   Other contributors: Hal Finney
-*
-*   Permission to use, copy, modify, and distribute this software for any
-*   purpose with or without fee is hereby granted, provided that the above
-*   copyright notice and this permission notice appear in all copies.
-*
-*   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-*   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-*   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-*   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-*   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-*   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-*   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-
-#ifndef AES_256_H
-#define AES_256_H
-
-#include "core/typedefs.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-    typedef struct {
-        uint8_t key[32];
-        uint8_t enckey[32];
-        uint8_t deckey[32];
-    } aes256_context;
-
-
-    void aes256_init(aes256_context *, uint8_t * /* key */);
-    void aes256_done(aes256_context *);
-    void aes256_encrypt_ecb(aes256_context *, uint8_t * /* plaintext */);
-    void aes256_decrypt_ecb(aes256_context *, uint8_t * /* cipertext */);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/thirdparty/misc/base64.c b/thirdparty/misc/base64.c
deleted file mode 100644
index 0929ae5db5..0000000000
--- a/thirdparty/misc/base64.c
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * File: base64.c
- * Description: Simple BASE64 conversion methods
- * Author: Ari Edelkind
- * License: Public Domain
- * Website: http://episec.com/people/edelkind/c.html
- */
-
-#include <string.h>
-
-char b64string[] =
-	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-long base64_encode (to, from, len)
-	char *to, *from;
-	unsigned int len;
-{
-	char *fromp = from;
-	char *top = to;
-	unsigned char cbyte;
-	unsigned char obyte;
-	char end[3];
-
-	for (; len >= 3; len -= 3) {
-		cbyte = *fromp++;
-		*top++ = b64string[(int)(cbyte >> 2)];
-		obyte = (cbyte << 4) & 0x30;		/* 0011 0000 */
-
-		cbyte = *fromp++;
-		obyte |= (cbyte >> 4);			/* 0000 1111 */
-		*top++ = b64string[(int)obyte];
-		obyte = (cbyte << 2) & 0x3C;		/* 0011 1100 */
-
-		cbyte = *fromp++;
-		obyte |= (cbyte >> 6);			/* 0000 0011 */
-		*top++ = b64string[(int)obyte];
-		*top++ = b64string[(int)(cbyte & 0x3F)];/* 0011 1111 */
-	}
-
-	if (len) {
-		end[0] = *fromp++;
-		if (--len) end[1] = *fromp++; else end[1] = 0;
-		end[2] = 0;
-
-		cbyte = end[0];
-		*top++ = b64string[(int)(cbyte >> 2)];
-		obyte = (cbyte << 4) & 0x30;		/* 0011 0000 */
-
-		cbyte = end[1];
-		obyte |= (cbyte >> 4);
-		*top++ = b64string[(int)obyte];
-		obyte = (cbyte << 2) & 0x3C;		/* 0011 1100 */
-
-		if (len) *top++ = b64string[(int)obyte];
-		else *top++ = '=';
-		*top++ = '=';
-	}
-	*top = 0;
-	return top - to;
-}
-
-/* badchar(): check if c is decent; puts either the */
-/* location of c or null into p.                  */
-#define badchar(c,p) (!(p = memchr(b64string, c, 64)))
-
-long base64_decode (to, from, len)
-	char *to, *from;
-	unsigned int len;
-{
-	char *fromp = from;
-	char *top = to;
-	char *p;
-	unsigned char cbyte;
-	unsigned char obyte;
-	int padding = 0;
-
-	for (; len >= 4; len -= 4) {
-		if ((cbyte = *fromp++) == '=') cbyte = 0;
-		else {
-			if (badchar(cbyte, p)) return -1;
-			cbyte = (p - b64string);
-		}
-		obyte = cbyte << 2;		/* 1111 1100 */
-
-		if ((cbyte = *fromp++) == '=') cbyte = 0;
-		else {
-			if (badchar(cbyte, p)) return -1;
-			cbyte = p - b64string;
-		}
-		obyte |= cbyte >> 4;		/* 0000 0011 */
-		*top++ = obyte;
-
-		obyte = cbyte << 4;		/* 1111 0000 */
-		if ((cbyte = *fromp++) == '=') { cbyte = 0; padding++; }
-		else {
-			padding = 0;
-			if (badchar (cbyte, p)) return -1;
-			cbyte = p - b64string;
-		}
-		obyte |= cbyte >> 2;		/* 0000 1111 */
-		*top++ = obyte;
-
-		obyte = cbyte << 6;		/* 1100 0000 */
-		if ((cbyte = *fromp++) == '=') { cbyte = 0; padding++; }
-		else {
-			padding = 0;
-			if (badchar (cbyte, p)) return -1;
-			cbyte = p - b64string;
-		}
-		obyte |= cbyte;			/* 0011 1111 */
-		*top++ = obyte;
-	}
-
-	*top = 0;
-	if (len) return -1;
-	return (top - to) - padding;
-}
-
diff --git a/thirdparty/misc/base64.h b/thirdparty/misc/base64.h
deleted file mode 100644
index ffcd0af973..0000000000
--- a/thirdparty/misc/base64.h
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- * File: base64.h
- * Description: Simple BASE64 conversion methods
- * Author: Ari Edelkind
- * License: Public Domain
- * Website: http://episec.com/people/edelkind/c.html
- */
-
-#ifndef BASE64_H
-#define BASE64_H
-
-extern "C" {
-
-long base64_encode(char *to, char *from, unsigned int len);
-long base64_decode(char *to, char *from, unsigned int len);
-};
-
-#endif /* BASE64_H */
diff --git a/thirdparty/misc/md5.cpp b/thirdparty/misc/md5.cpp
deleted file mode 100644
index 1653ab0be5..0000000000
--- a/thirdparty/misc/md5.cpp
+++ /dev/null
@@ -1,267 +0,0 @@
-/*
- **********************************************************************
- ** md5.c                                                            **
- ** RSA Data Security, Inc. MD5 Message Digest Algorithm             **
- ** Created: 2/17/90 RLR                                             **
- ** Revised: 1/91 SRD,AJ,BSK,JT Reference C Version                  **
- **********************************************************************
- */
-
-/*
- **********************************************************************
- ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
- **                                                                  **
- ** License to copy and use this software is granted provided that   **
- ** it is identified as the "RSA Data Security, Inc. MD5 Message     **
- ** Digest Algorithm" in all material mentioning or referencing this **
- ** software or this function.                                       **
- **                                                                  **
- ** License is also granted to make and use derivative works         **
- ** provided that such works are identified as "derived from the RSA **
- ** Data Security, Inc. MD5 Message Digest Algorithm" in all         **
- ** material mentioning or referencing the derived work.             **
- **                                                                  **
- ** RSA Data Security, Inc. makes no representations concerning      **
- ** either the merchantability of this software or the suitability   **
- ** of this software for any particular purpose.  It is provided "as **
- ** is" without express or implied warranty of any kind.             **
- **                                                                  **
- ** These notices must be retained in any copies of any part of this **
- ** documentation and/or software.                                   **
- **********************************************************************
- */
-
-/* -- include the following line if the md5.h header file is separate -- */
-#include "md5.h"
-
-/* forward declaration */
-static void Transform (uint32_t *buf, uint32_t *in);
-
-
-static unsigned char PADDING[64] = {
-  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
-
-/* F, G and H are basic MD5 functions: selection, majority, parity */
-#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
-#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
-#define H(x, y, z) ((x) ^ (y) ^ (z))
-#define I(x, y, z) ((y) ^ ((x) | (~z)))
-
-/* ROTATE_LEFT rotates x left n bits */
-#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
-
-/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
-/* Rotation is separate from addition to prevent recomputation */
-#define FF(a, b, c, d, x, s, ac) \
-  {(a) += F ((b), (c), (d)) + (x) + (uint32_t)(ac); \
-   (a) = ROTATE_LEFT ((a), (s)); \
-   (a) += (b); \
-  }
-#define GG(a, b, c, d, x, s, ac) \
-  {(a) += G ((b), (c), (d)) + (x) + (uint32_t)(ac); \
-   (a) = ROTATE_LEFT ((a), (s)); \
-   (a) += (b); \
-  }
-#define HH(a, b, c, d, x, s, ac) \
-  {(a) += H ((b), (c), (d)) + (x) + (uint32_t)(ac); \
-   (a) = ROTATE_LEFT ((a), (s)); \
-   (a) += (b); \
-  }
-#define II(a, b, c, d, x, s, ac) \
-  {(a) += I ((b), (c), (d)) + (x) + (uint32_t)(ac); \
-   (a) = ROTATE_LEFT ((a), (s)); \
-   (a) += (b); \
-  }
-
-void MD5Init (MD5_CTX *mdContext)
-{
-  mdContext->i[0] = mdContext->i[1] = (uint32_t)0;
-
-  /* Load magic initialization constants.
-   */
-  mdContext->buf[0] = (uint32_t)0x67452301;
-  mdContext->buf[1] = (uint32_t)0xefcdab89;
-  mdContext->buf[2] = (uint32_t)0x98badcfe;
-  mdContext->buf[3] = (uint32_t)0x10325476;
-}
-
-void MD5Update (MD5_CTX *mdContext,unsigned char *inBuf,unsigned int inLen) {
-  uint32_t in[16];
-  int mdi;
-  unsigned int i, ii;
-
-  /* compute number of bytes mod 64 */
-  mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
-
-  /* update number of bits */
-  if ((mdContext->i[0] + ((uint32_t)inLen << 3)) < mdContext->i[0])
-    mdContext->i[1]++;
-  mdContext->i[0] += ((uint32_t)inLen << 3);
-  mdContext->i[1] += ((uint32_t)inLen >> 29);
-
-  while (inLen--) {
-    /* add new character to buffer, increment mdi */
-    mdContext->in[mdi++] = *inBuf++;
-
-    /* transform if necessary */
-    if (mdi == 0x40) {
-      for (i = 0, ii = 0; i < 16; i++, ii += 4)
-	in[i] = (((uint32_t)mdContext->in[ii+3]) << 24) |
-		(((uint32_t)mdContext->in[ii+2]) << 16) |
-		(((uint32_t)mdContext->in[ii+1]) << 8) |
-		((uint32_t)mdContext->in[ii]);
-      Transform (mdContext->buf, in);
-      mdi = 0;
-    }
-  }
-}
-
-void MD5Final (MD5_CTX *mdContext) {
-  uint32_t in[16];
-  int mdi;
-  unsigned int i, ii;
-  unsigned int padLen;
-
-  /* save number of bits */
-  in[14] = mdContext->i[0];
-  in[15] = mdContext->i[1];
-
-  /* compute number of bytes mod 64 */
-  mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
-
-  /* pad out to 56 mod 64 */
-  padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
-  MD5Update (mdContext, PADDING, padLen);
-
-  /* append length in bits and transform */
-  for (i = 0, ii = 0; i < 14; i++, ii += 4)
-    in[i] = (((uint32_t)mdContext->in[ii+3]) << 24) |
-	    (((uint32_t)mdContext->in[ii+2]) << 16) |
-	    (((uint32_t)mdContext->in[ii+1]) << 8) |
-	    ((uint32_t)mdContext->in[ii]);
-  Transform (mdContext->buf, in);
-
-  /* store buffer in digest */
-  for (i = 0, ii = 0; i < 4; i++, ii += 4) {
-    mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF);
-    mdContext->digest[ii+1] =
-      (unsigned char)((mdContext->buf[i] >> 8) & 0xFF);
-    mdContext->digest[ii+2] =
-      (unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
-    mdContext->digest[ii+3] =
-      (unsigned char)((mdContext->buf[i] >> 24) & 0xFF);
-  }
-}
-
-/* Basic MD5 step. Transform buf based on in.
- */
-static void Transform (uint32_t *buf, uint32_t *in) {
-  uint32_t a = buf[0], b = buf[1], c = buf[2], d = buf[3];
-
-  /* Round 1 */
-#define S11 7
-#define S12 12
-#define S13 17
-#define S14 22
-  FF ( a, b, c, d, in[ 0], S11, 3614090360); /* 1 */
-  FF ( d, a, b, c, in[ 1], S12, 3905402710); /* 2 */
-  FF ( c, d, a, b, in[ 2], S13,  606105819); /* 3 */
-  FF ( b, c, d, a, in[ 3], S14, 3250441966); /* 4 */
-  FF ( a, b, c, d, in[ 4], S11, 4118548399); /* 5 */
-  FF ( d, a, b, c, in[ 5], S12, 1200080426); /* 6 */
-  FF ( c, d, a, b, in[ 6], S13, 2821735955); /* 7 */
-  FF ( b, c, d, a, in[ 7], S14, 4249261313); /* 8 */
-  FF ( a, b, c, d, in[ 8], S11, 1770035416); /* 9 */
-  FF ( d, a, b, c, in[ 9], S12, 2336552879); /* 10 */
-  FF ( c, d, a, b, in[10], S13, 4294925233); /* 11 */
-  FF ( b, c, d, a, in[11], S14, 2304563134); /* 12 */
-  FF ( a, b, c, d, in[12], S11, 1804603682); /* 13 */
-  FF ( d, a, b, c, in[13], S12, 4254626195); /* 14 */
-  FF ( c, d, a, b, in[14], S13, 2792965006); /* 15 */
-  FF ( b, c, d, a, in[15], S14, 1236535329); /* 16 */
-
-  /* Round 2 */
-#define S21 5
-#define S22 9
-#define S23 14
-#define S24 20
-  GG ( a, b, c, d, in[ 1], S21, 4129170786); /* 17 */
-  GG ( d, a, b, c, in[ 6], S22, 3225465664); /* 18 */
-  GG ( c, d, a, b, in[11], S23,  643717713); /* 19 */
-  GG ( b, c, d, a, in[ 0], S24, 3921069994); /* 20 */
-  GG ( a, b, c, d, in[ 5], S21, 3593408605); /* 21 */
-  GG ( d, a, b, c, in[10], S22,   38016083); /* 22 */
-  GG ( c, d, a, b, in[15], S23, 3634488961); /* 23 */
-  GG ( b, c, d, a, in[ 4], S24, 3889429448); /* 24 */
-  GG ( a, b, c, d, in[ 9], S21,  568446438); /* 25 */
-  GG ( d, a, b, c, in[14], S22, 3275163606); /* 26 */
-  GG ( c, d, a, b, in[ 3], S23, 4107603335); /* 27 */
-  GG ( b, c, d, a, in[ 8], S24, 1163531501); /* 28 */
-  GG ( a, b, c, d, in[13], S21, 2850285829); /* 29 */
-  GG ( d, a, b, c, in[ 2], S22, 4243563512); /* 30 */
-  GG ( c, d, a, b, in[ 7], S23, 1735328473); /* 31 */
-  GG ( b, c, d, a, in[12], S24, 2368359562); /* 32 */
-
-  /* Round 3 */
-#define S31 4
-#define S32 11
-#define S33 16
-#define S34 23
-  HH ( a, b, c, d, in[ 5], S31, 4294588738); /* 33 */
-  HH ( d, a, b, c, in[ 8], S32, 2272392833); /* 34 */
-  HH ( c, d, a, b, in[11], S33, 1839030562); /* 35 */
-  HH ( b, c, d, a, in[14], S34, 4259657740); /* 36 */
-  HH ( a, b, c, d, in[ 1], S31, 2763975236); /* 37 */
-  HH ( d, a, b, c, in[ 4], S32, 1272893353); /* 38 */
-  HH ( c, d, a, b, in[ 7], S33, 4139469664); /* 39 */
-  HH ( b, c, d, a, in[10], S34, 3200236656); /* 40 */
-  HH ( a, b, c, d, in[13], S31,  681279174); /* 41 */
-  HH ( d, a, b, c, in[ 0], S32, 3936430074); /* 42 */
-  HH ( c, d, a, b, in[ 3], S33, 3572445317); /* 43 */
-  HH ( b, c, d, a, in[ 6], S34,   76029189); /* 44 */
-  HH ( a, b, c, d, in[ 9], S31, 3654602809); /* 45 */
-  HH ( d, a, b, c, in[12], S32, 3873151461); /* 46 */
-  HH ( c, d, a, b, in[15], S33,  530742520); /* 47 */
-  HH ( b, c, d, a, in[ 2], S34, 3299628645); /* 48 */
-
-  /* Round 4 */
-#define S41 6
-#define S42 10
-#define S43 15
-#define S44 21
-  II ( a, b, c, d, in[ 0], S41, 4096336452); /* 49 */
-  II ( d, a, b, c, in[ 7], S42, 1126891415); /* 50 */
-  II ( c, d, a, b, in[14], S43, 2878612391); /* 51 */
-  II ( b, c, d, a, in[ 5], S44, 4237533241); /* 52 */
-  II ( a, b, c, d, in[12], S41, 1700485571); /* 53 */
-  II ( d, a, b, c, in[ 3], S42, 2399980690); /* 54 */
-  II ( c, d, a, b, in[10], S43, 4293915773); /* 55 */
-  II ( b, c, d, a, in[ 1], S44, 2240044497); /* 56 */
-  II ( a, b, c, d, in[ 8], S41, 1873313359); /* 57 */
-  II ( d, a, b, c, in[15], S42, 4264355552); /* 58 */
-  II ( c, d, a, b, in[ 6], S43, 2734768916); /* 59 */
-  II ( b, c, d, a, in[13], S44, 1309151649); /* 60 */
-  II ( a, b, c, d, in[ 4], S41, 4149444226); /* 61 */
-  II ( d, a, b, c, in[11], S42, 3174756917); /* 62 */
-  II ( c, d, a, b, in[ 2], S43,  718787259); /* 63 */
-  II ( b, c, d, a, in[ 9], S44, 3951481745); /* 64 */
-
-  buf[0] += a;
-  buf[1] += b;
-  buf[2] += c;
-  buf[3] += d;
-}
-
-/*
- **********************************************************************
- ** End of md5.c                                                     **
- ******************************* (cut) ********************************
- */
diff --git a/thirdparty/misc/md5.h b/thirdparty/misc/md5.h
deleted file mode 100644
index 14b3cd3ddf..0000000000
--- a/thirdparty/misc/md5.h
+++ /dev/null
@@ -1,61 +0,0 @@
-#ifndef MD5_H
-#define MD5_H
-
-/*
- **********************************************************************
- ** md5.h -- Header file for implementation of MD5                   **
- ** RSA Data Security, Inc. MD5 Message Digest Algorithm             **
- ** Created: 2/17/90 RLR                                             **
- ** Revised: 12/27/90 SRD,AJ,BSK,JT Reference C version              **
- ** Revised (for MD5): RLR 4/27/91                                   **
- **   -- G modified to have y&~z instead of y&z                      **
- **   -- FF, GG, HH modified to add in last register done            **
- **   -- Access pattern: round 2 works mod 5, round 3 works mod 3    **
- **   -- distinct additive constant for each step                    **
- **   -- round 4 added, working mod 7                                **
- **********************************************************************
- */
-
-/*
- **********************************************************************
- ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
- **                                                                  **
- ** License to copy and use this software is granted provided that   **
- ** it is identified as the "RSA Data Security, Inc. MD5 Message     **
- ** Digest Algorithm" in all material mentioning or referencing this **
- ** software or this function.                                       **
- **                                                                  **
- ** License is also granted to make and use derivative works         **
- ** provided that such works are identified as "derived from the RSA **
- ** Data Security, Inc. MD5 Message Digest Algorithm" in all         **
- ** material mentioning or referencing the derived work.             **
- **                                                                  **
- ** RSA Data Security, Inc. makes no representations concerning      **
- ** either the merchantability of this software or the suitability   **
- ** of this software for any particular purpose.  It is provided "as **
- ** is" without express or implied warranty of any kind.             **
- **                                                                  **
- ** These notices must be retained in any copies of any part of this **
- ** documentation and/or software.                                   **
- **********************************************************************
- */
-
-/* NOT typedef a 32 bit type */
-
-#include "core/typedefs.h"
-
-/* Data structure for MD5 (Message Digest) computation */
-typedef struct {
-  uint32_t i[2];                   /* number of _bits_ handled mod 2^64 */
-  uint32_t buf[4];                                    /* scratch buffer */
-  unsigned char in[64];                              /* input buffer */
-  unsigned char digest[16];     /* actual digest after MD5Final call */
-} MD5_CTX;
-
-void MD5Init (MD5_CTX *mdContext);
-void MD5Update (MD5_CTX *mdContext,unsigned char *inBuf,unsigned int inLen);
-void MD5Final (MD5_CTX *mdContext);
-
-
-
-#endif // MD5_H
diff --git a/thirdparty/misc/sha256.c b/thirdparty/misc/sha256.c
deleted file mode 100644
index 68a4339af9..0000000000
--- a/thirdparty/misc/sha256.c
+++ /dev/null
@@ -1,245 +0,0 @@
-/*
-*   SHA-256 implementation.
-*
-*   Copyright (c) 2010 Ilya O. Levin, http://www.literatecode.com
-*
-*   Permission to use, copy, modify, and distribute this software for any
-*   purpose with or without fee is hereby granted, provided that the above
-*   copyright notice and this permission notice appear in all copies.
-*
-*   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-*   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-*   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-*   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-*   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-*   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-*   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-#define SWAP_BYTES
-// #define USE_STD_MEMCPY
-// #define SELF_TEST
-
-#ifdef USE_STD_MEMCPY
-#include <string.h>
-#endif
-#include "sha256.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define RL(x,n)   (((x) << n) | ((x) >> (32 - n)))
-#define RR(x,n)   (((x) >> n) | ((x) << (32 - n)))
-
-#define S0(x)  (RR((x), 2) ^ RR((x),13) ^ RR((x),22))
-#define S1(x)  (RR((x), 6) ^ RR((x),11) ^ RR((x),25))
-#define G0(x)  (RR((x), 7) ^ RR((x),18) ^ ((x) >> 3))
-#define G1(x)  (RR((x),17) ^ RR((x),19) ^ ((x) >> 10))
-
-#ifdef SWAP_BYTES
-#define BSWP(x,y)  _bswapw((uint32_t *)(x), (uint32_t)(y))
-#else
-#define BSWP(p,n)
-#endif
-#ifdef USE_STD_MEMCPY
-#define MEMCP(x,y,z) memcpy((x),(y),(z))
-#else
-#define MEMCP(x,y,z) _memcp((x),(y),(z))
-#endif
-
-#ifndef __cdecl
-#define __cdecl
-#endif
-
-static const uint32_t K[64] = {
-     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
-     0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
-     0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
-     0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-     0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
-     0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-     0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
-     0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-     0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
-     0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
-     0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
-     0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
-};
-
-/* -------------------------------------------------------------------------- */
-static void _bswapw(uint32_t *p, uint32_t i)
-{
-    while (i--) p[i] = (RR(p[i],24) & 0x00ff00ff) | (RR(p[i],8) & 0xff00ff00);
-
-} /* _bswapw */
-
-/* -------------------------------------------------------------------------- */
-#ifndef USE_STD_MEMCPY
-void * __cdecl _memcp (void *d, const void *s, uint32_t sz)
-{
-    void *rv = d;
-
-    while (sz--) *(char *)d = *(char *)s, d = (char *)d + 1,  s = (char *)s + 1;
-
-    return(rv);
-} /* _memcp */
-#endif
-
-/* -------------------------------------------------------------------------- */
-static void _rtrf(uint32_t *b, uint32_t *p, uint32_t i, uint32_t j)
-{
-    #define B(x, y) b[(x-y) & 7]
-    #define P(x, y) p[(x+y) & 15]
-
-    B(7,i) += (j ? (p[i & 15] += G1(P(i,14)) + P(i,9) + G0(P(i,1))) : p[i & 15])
-              + K[i+j] + S1(B(4,i))
-              + (B(6,i) ^ (B(4,i) & (B(5,i) ^ B(6,i))));
-    B(3,i) += B(7,i);
-    B(7,i) += S0(B(0,i)) + ( (B(0,i) & B(1,i)) | (B(2,i) & (B(0,i) ^ B(1,i))) );
-
-    #undef P
-    #undef B
-} /* _rtrf */
-
-/* -------------------------------------------------------------------------- */
-static void _hash(sha256_context *ctx)
-{
-    uint32_t b[8], *p, j;
-
-    b[0] = ctx->hash[0]; b[1] = ctx->hash[1]; b[2] = ctx->hash[2];
-    b[3] = ctx->hash[3]; b[4] = ctx->hash[4]; b[5] = ctx->hash[5];
-    b[6] = ctx->hash[6]; b[7] = ctx->hash[7];
-
-    for (p = ctx->buf, j = 0; j < 64; j += 16)
-        _rtrf(b, p,  0, j), _rtrf(b, p,  1, j), _rtrf(b, p,  2, j),
-        _rtrf(b, p,  3, j), _rtrf(b, p,  4, j), _rtrf(b, p,  5, j),
-        _rtrf(b, p,  6, j), _rtrf(b, p,  7, j), _rtrf(b, p,  8, j),
-        _rtrf(b, p,  9, j), _rtrf(b, p, 10, j), _rtrf(b, p, 11, j),
-        _rtrf(b, p, 12, j), _rtrf(b, p, 13, j), _rtrf(b, p, 14, j),
-        _rtrf(b, p, 15, j);
-
-    ctx->hash[0] += b[0]; ctx->hash[1] += b[1]; ctx->hash[2] += b[2];
-    ctx->hash[3] += b[3]; ctx->hash[4] += b[4]; ctx->hash[5] += b[5];
-    ctx->hash[6] += b[6]; ctx->hash[7] += b[7];
-
-} /* _hash */
-
-/* -------------------------------------------------------------------------- */
-void sha256_init(sha256_context ctx[1])
-{
-    ctx->len[0] = ctx->len[1] = 0;
-    ctx->hash[0] = 0x6a09e667; ctx->hash[1] = 0xbb67ae85;
-    ctx->hash[2] = 0x3c6ef372; ctx->hash[3] = 0xa54ff53a;
-    ctx->hash[4] = 0x510e527f; ctx->hash[5] = 0x9b05688c;
-    ctx->hash[6] = 0x1f83d9ab; ctx->hash[7] = 0x5be0cd19;
-
-} /* sha256_init */
-
-/* -------------------------------------------------------------------------- */
-void sha256_hash(sha256_context *ctx, uint8_t *dat, uint32_t sz)
-{
-    register uint32_t i = ctx->len[0] & 63, l, j;
-
-    if ((ctx->len[0] += sz) < sz)  ++(ctx->len[1]);
-
-    for (j = 0, l = 64-i; sz >= l; j += l, sz -= l, l = 64, i = 0)
-    {
-        MEMCP(&ctx->buf[i], &dat[j], l);
-        BSWP(ctx->buf, 16 );
-        _hash(ctx);
-    }
-    MEMCP(&ctx->buf[i], &dat[j], sz);
-
-} /* _hash */
-
-/* -------------------------------------------------------------------------- */
-void sha256_done(sha256_context *ctx, uint8_t *buf)
-{
-    uint32_t i = (uint32_t)(ctx->len[0] & 63), j = ((~i) & 3) << 3;
-
-    BSWP(ctx->buf, (i + 3) >> 2);
-
-    ctx->buf[i >> 2] &= 0xffffff80 << j;  /* add padding */
-    ctx->buf[i >> 2] |= 0x00000080 << j;
-
-    if (i < 56) i = (i >> 2) + 1;
-       else ctx->buf[15] ^= (i < 60) ? ctx->buf[15] : 0, _hash(ctx), i = 0;
-
-    while (i < 14) ctx->buf[i++] = 0;
-
-    ctx->buf[14] = (ctx->len[1] << 3)|(ctx->len[0] >> 29); /* add length */
-    ctx->buf[15] = ctx->len[0] << 3;
-
-    _hash(ctx);
-
-    for (i = 0; i < 32; i++)
-       ctx->buf[i % 16] = 0, /* may remove this line in case of a DIY cleanup */
-       buf[i] = (uint8_t)(ctx->hash[i >> 2] >> ((~i & 3) << 3));
-
-} /* sha256_done */
-
-
-#ifdef SELF_TEST
-#pragma warning (push, 0)
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#pragma warning(pop)
-
-char *buf[] = {
-    "",
-    "e3b0c442 98fc1c14 9afbf4c8 996fb924 27ae41e4 649b934c a495991b 7852b855",
-
-    "abc",
-    "ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad",
-
-    "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
-    "248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1",
-
-    "The quick brown fox jumps over the lazy dog",
-    "d7a8fbb3 07d78094 69ca9abc b0082e4f 8d5651e4 6d3cdb76 2d02d0bf 37c9e592",
-
-    "The quick brown fox jumps over the lazy cog", /* avalanche effect test */
-    "e4c4d8f3 bf76b692 de791a17 3e053211 50f7a345 b46484fe 427f6acc 7ecc81be",
-
-    "bhn5bjmoniertqea40wro2upyflkydsibsk8ylkmgbvwi420t44cq034eou1szc1k0mk46oeb7ktzmlxqkbte2sy",
-    "9085df2f 02e0cc45 5928d0f5 1b27b4bf 1d9cd260 a66ed1fd a11b0a3f f5756d99"
-};
-
-int main(int argc, char *argv[])
-{
-    sha256_context ctx;
-    uint8_t hv[32];
-    uint32_t i, j;
-
-    for (j = 0; j < (sizeof(buf)/sizeof(buf[0])); j += 2)
-    {
-        sha256_init(&ctx);
-        sha256_hash(&ctx, (uint8_t *)buf[j], (uint32_t)strlen(buf[j]));
-        sha256_done(&ctx, hv);
-        printf("input = %s\ndigest: %s\nresult: ", buf[j], buf[j+1]);
-        for (i = 0; i < 32; i++) printf("%02x%s", hv[i], ((i%4)==3)?" ":"");
-        printf("\n\n");
-    }
-
-    for (j = 1; j < (uint32_t)argc; j++)
-    {
-        printf("argv[%d]: %s\nresult: ", (int)j, argv[j]);
-        sha256_init(&ctx);
-        sha256_hash(&ctx, (uint8_t *)argv[j], (uint32_t)strlen(argv[j]));
-        sha256_done(&ctx, hv);
-        for (i = 0; i < 32; i++) printf("%02x%s", hv[i], ((i%4)==3)?" ":"");
-        printf("\n\n");
-    }
-
-    return 0;
-} /* main */
-#endif
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/thirdparty/misc/sha256.h b/thirdparty/misc/sha256.h
deleted file mode 100644
index e19e56b4cc..0000000000
--- a/thirdparty/misc/sha256.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-*   SHA-256 implementation.
-*
-*   Copyright (c) 2010 Ilya O. Levin, http://www.literatecode.com
-*
-*   Permission to use, copy, modify, and distribute this software for any
-*   purpose with or without fee is hereby granted, provided that the above
-*   copyright notice and this permission notice appear in all copies.
-*
-*   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-*   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-*   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-*   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-*   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-*   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-*   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-#ifdef _MSC_VER
-#ifndef uint8_t
-typedef unsigned __int8 uint8_t;
-#endif
-#ifndef uint32_t
-typedef unsigned __int32 uint32_t;
-#endif
-#ifndef uint64_t
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#endif
-#else
-#include <stdint.h>
-#endif
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-   typedef struct {
-       uint32_t buf[16];
-       uint32_t hash[8];
-       uint32_t len[2];
-   } sha256_context;
-
-   void sha256_init(sha256_context *);
-   void sha256_hash(sha256_context *, uint8_t * /* data */, uint32_t /* len */);
-   void sha256_done(sha256_context *, uint8_t * /* hash */);
-
-#ifdef __cplusplus
-}
-#endif