mirror of
https://github.com/godotengine/godot
synced 2024-09-04 21:58:28 +00:00
Merge pull request #30239 from Faless/crypto/crypto_core
CryptoCore class to access to base crypto utils.
This commit is contained in:
commit
e9d624d7ce
|
@ -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
|
||||
|
|
|
@ -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",
|
||||
|
|
|
@ -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]);
|
||||
|
|
|
@ -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());
|
||||
|
|
|
@ -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")
|
||||
|
|
146
core/math/crypto_core.cpp
Normal file
146
core/math/crypto_core.cpp
Normal file
|
@ -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;
|
||||
}
|
89
core/math/crypto_core.h
Normal file
89
core/math/crypto_core.h
Normal file
|
@ -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
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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];
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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>
|
||||
|
|
|
@ -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);
|
||||
|
|
20
thirdparty/README.md
vendored
20
thirdparty/README.md
vendored
|
@ -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)
|
||||
|
|
13
thirdparty/mbedtls/include/godot_core_mbedtls_config.h
vendored
Normal file
13
thirdparty/mbedtls/include/godot_core_mbedtls_config.h
vendored
Normal file
|
@ -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
|
18
thirdparty/mbedtls/library/godot_core_mbedtls_platform.c
vendored
Normal file
18
thirdparty/mbedtls/library/godot_core_mbedtls_platform.c
vendored
Normal file
|
@ -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
|
||||
|
397
thirdparty/misc/aes256.cpp
vendored
397
thirdparty/misc/aes256.cpp
vendored
|
@ -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 */
|
46
thirdparty/misc/aes256.h
vendored
46
thirdparty/misc/aes256.h
vendored
|
@ -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
|
118
thirdparty/misc/base64.c
vendored
118
thirdparty/misc/base64.c
vendored
|
@ -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;
|
||||
}
|
||||
|
18
thirdparty/misc/base64.h
vendored
18
thirdparty/misc/base64.h
vendored
|
@ -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 */
|
267
thirdparty/misc/md5.cpp
vendored
267
thirdparty/misc/md5.cpp
vendored
|
@ -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) ********************************
|
||||
*/
|
61
thirdparty/misc/md5.h
vendored
61
thirdparty/misc/md5.h
vendored
|
@ -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
|
245
thirdparty/misc/sha256.c
vendored
245
thirdparty/misc/sha256.c
vendored
|
@ -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
|
50
thirdparty/misc/sha256.h
vendored
50
thirdparty/misc/sha256.h
vendored
|
@ -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
|
Loading…
Reference in a new issue