From e7a707ea394a7deca004cd88c636a35ed0cf2130 Mon Sep 17 00:00:00 2001 From: lzx <393768033@qq.com> Date: Fri, 4 Jul 2025 17:47:19 +0800 Subject: [PATCH] add algo files --- README.md | 9 + blake2b/blake2b.c | 237 ++++ blake2b/blake2b.h | 24 + heavyHash/DiagonalMatrix.h | 192 +++ heavyHash/Makefile | 14 + heavyHash/Matrix.h | 25 + heavyHash/Reflector.h | 19 + heavyHash/Rotator.h | 17 + heavyHash/Svd.h | 45 + heavyHash/Vector.h | 22 + heavyHash/heavyhash.c | 150 +++ heavyHash/heavyhash.h | 98 ++ heavyHash/heavyhash.o | Bin 0 -> 5296 bytes heavyHash/libkas.a | Bin 0 -> 37286 bytes heavyHash/obtc.c | 907 +++++++++++++ heavyHash/obtc.h | 52 + heavyHash/obtc.o | Bin 0 -> 25504 bytes heavyHash/sha3.c | 199 +++ heavyHash/sha3.h | 51 + heavyHash/sha3.o | Bin 0 -> 4632 bytes heavyHash/singular.h | 42 + heavyHash/test.c | 183 +++ heavyHash/uint256.h | 44 + heavyHash/xoshiro256pp.h | 15 + randomx/a.exe | Bin 0 -> 631893 bytes randomx/aes_hash.cpp | 241 ++++ randomx/aes_hash.hpp | 40 + randomx/allocator.cpp | 60 + randomx/allocator.hpp | 46 + randomx/argon2.h | 261 ++++ randomx/argon2_avx2.c | 175 +++ randomx/argon2_core.c | 396 ++++++ randomx/argon2_core.h | 163 +++ randomx/argon2_ref.c | 181 +++ randomx/argon2_ssse3.c | 183 +++ randomx/asm/configuration.asm | 48 + randomx/asm/program_epilogue_linux.inc | 10 + randomx/asm/program_epilogue_store.inc | 19 + randomx/asm/program_epilogue_win64.inc | 24 + randomx/asm/program_loop_load.inc | 28 + randomx/asm/program_loop_store.inc | 18 + randomx/asm/program_prologue_linux.inc | 34 + randomx/asm/program_prologue_win64.inc | 47 + randomx/asm/program_read_dataset.inc | 17 + .../asm/program_read_dataset_sshash_fin.inc | 10 + .../asm/program_read_dataset_sshash_init.inc | 17 + randomx/asm/program_sshash_constants.inc | 24 + randomx/asm/program_sshash_load.inc | 8 + randomx/asm/program_sshash_prefetch.inc | 4 + randomx/asm/program_xmm_constants.inc | 6 + randomx/asm/randomx_reciprocal.inc | 7 + randomx/assembly_generator_x86.cpp | 612 +++++++++ randomx/assembly_generator_x86.hpp | 94 ++ randomx/blake2/blake2-impl.h | 76 ++ randomx/blake2/blake2.h | 116 ++ randomx/blake2/blake2b.c | 409 ++++++ randomx/blake2/blamka-round-avx2.h | 189 +++ randomx/blake2/blamka-round-ref.h | 73 ++ randomx/blake2/blamka-round-ssse3.h | 162 +++ randomx/blake2/endian.h | 107 ++ randomx/blake2_generator.cpp | 62 + randomx/blake2_generator.hpp | 46 + randomx/bytecode_machine.cpp | 494 ++++++++ randomx/bytecode_machine.hpp | 322 +++++ randomx/common.hpp | 187 +++ randomx/configuration.h | 125 ++ randomx/cpu.cpp | 72 ++ randomx/cpu.hpp | 49 + randomx/dataset.cpp | 212 ++++ randomx/dataset.hpp | 94 ++ randomx/instruction.cpp | 390 ++++++ randomx/instruction.hpp | 149 +++ randomx/instruction_weights.hpp | 73 ++ randomx/instructions_portable.cpp | 193 +++ randomx/intrin_portable.h | 738 +++++++++++ randomx/jit_compiler.hpp | 37 + randomx/jit_compiler_fallback.hpp | 76 ++ randomx/jit_compiler_x86.cpp | 845 +++++++++++++ randomx/jit_compiler_x86.hpp | 142 +++ randomx/jit_compiler_x86_static.S | 232 ++++ randomx/jit_compiler_x86_static.asm | 227 ++++ randomx/jit_compiler_x86_static.hpp | 51 + .../mingw-std-threads-master/CMakeLists.txt | 35 + randomx/mingw-std-threads-master/LICENSE | 24 + randomx/mingw-std-threads-master/README.md | 58 + .../cmake_stdheaders_generator/CMakeLists.txt | 78 ++ .../cmake_stdheaders_generator/template.cpp | 11 + .../mingw.condition_variable.h | 564 +++++++++ .../mingw-std-threads-master/mingw.future.h | 1118 +++++++++++++++++ .../mingw-std-threads-master/mingw.invoke.h | 109 ++ .../mingw-std-threads-master/mingw.mutex.h | 491 ++++++++ .../mingw.shared_mutex.h | 503 ++++++++ .../mingw-std-threads-master/mingw.thread.h | 360 ++++++ .../tests/CMakeLists.txt | 18 + .../mingw-std-threads-master/tests/tests.cpp | 450 +++++++ .../Generate-StdLikeHeaders.ps1 | 226 ++++ .../generate_std_like_headers.bat | 1 + .../generate_std_like_headers_interactive.bat | 1 + randomx/program.hpp | 71 ++ randomx/randomx.cpp | 492 ++++++++ randomx/randomx.h | 245 ++++ randomx/reciprocal.c | 80 ++ randomx/reciprocal.h | 48 + randomx/soft_aes.cpp | 364 ++++++ randomx/soft_aes.h | 46 + randomx/superscalar.cpp | 903 +++++++++++++ randomx/superscalar.hpp | 60 + randomx/superscalar_program.hpp | 84 ++ randomx/virtual_machine.cpp | 141 +++ randomx/virtual_machine.hpp | 85 ++ randomx/virtual_memory.cpp | 163 +++ randomx/virtual_memory.hpp | 42 + randomx/vm_compiled.cpp | 82 ++ randomx/vm_compiled.hpp | 77 ++ randomx/vm_compiled_light.cpp | 72 ++ randomx/vm_compiled_light.hpp | 68 + randomx/vm_interpreted.cpp | 162 +++ randomx/vm_interpreted.hpp | 75 ++ randomx/vm_interpreted_light.cpp | 56 + randomx/vm_interpreted_light.hpp | 61 + sha3x/sha3x.c | 220 ++++ sha3x/sha3x.h | 35 + 122 files changed, 18845 insertions(+) create mode 100644 blake2b/blake2b.c create mode 100644 blake2b/blake2b.h create mode 100644 heavyHash/DiagonalMatrix.h create mode 100644 heavyHash/Makefile create mode 100644 heavyHash/Matrix.h create mode 100644 heavyHash/Reflector.h create mode 100644 heavyHash/Rotator.h create mode 100644 heavyHash/Svd.h create mode 100644 heavyHash/Vector.h create mode 100644 heavyHash/heavyhash.c create mode 100644 heavyHash/heavyhash.h create mode 100644 heavyHash/heavyhash.o create mode 100644 heavyHash/libkas.a create mode 100644 heavyHash/obtc.c create mode 100644 heavyHash/obtc.h create mode 100644 heavyHash/obtc.o create mode 100644 heavyHash/sha3.c create mode 100644 heavyHash/sha3.h create mode 100644 heavyHash/sha3.o create mode 100644 heavyHash/singular.h create mode 100644 heavyHash/test.c create mode 100644 heavyHash/uint256.h create mode 100644 heavyHash/xoshiro256pp.h create mode 100644 randomx/a.exe create mode 100644 randomx/aes_hash.cpp create mode 100644 randomx/aes_hash.hpp create mode 100644 randomx/allocator.cpp create mode 100644 randomx/allocator.hpp create mode 100644 randomx/argon2.h create mode 100644 randomx/argon2_avx2.c create mode 100644 randomx/argon2_core.c create mode 100644 randomx/argon2_core.h create mode 100644 randomx/argon2_ref.c create mode 100644 randomx/argon2_ssse3.c create mode 100644 randomx/asm/configuration.asm create mode 100644 randomx/asm/program_epilogue_linux.inc create mode 100644 randomx/asm/program_epilogue_store.inc create mode 100644 randomx/asm/program_epilogue_win64.inc create mode 100644 randomx/asm/program_loop_load.inc create mode 100644 randomx/asm/program_loop_store.inc create mode 100644 randomx/asm/program_prologue_linux.inc create mode 100644 randomx/asm/program_prologue_win64.inc create mode 100644 randomx/asm/program_read_dataset.inc create mode 100644 randomx/asm/program_read_dataset_sshash_fin.inc create mode 100644 randomx/asm/program_read_dataset_sshash_init.inc create mode 100644 randomx/asm/program_sshash_constants.inc create mode 100644 randomx/asm/program_sshash_load.inc create mode 100644 randomx/asm/program_sshash_prefetch.inc create mode 100644 randomx/asm/program_xmm_constants.inc create mode 100644 randomx/asm/randomx_reciprocal.inc create mode 100644 randomx/assembly_generator_x86.cpp create mode 100644 randomx/assembly_generator_x86.hpp create mode 100644 randomx/blake2/blake2-impl.h create mode 100644 randomx/blake2/blake2.h create mode 100644 randomx/blake2/blake2b.c create mode 100644 randomx/blake2/blamka-round-avx2.h create mode 100644 randomx/blake2/blamka-round-ref.h create mode 100644 randomx/blake2/blamka-round-ssse3.h create mode 100644 randomx/blake2/endian.h create mode 100644 randomx/blake2_generator.cpp create mode 100644 randomx/blake2_generator.hpp create mode 100644 randomx/bytecode_machine.cpp create mode 100644 randomx/bytecode_machine.hpp create mode 100644 randomx/common.hpp create mode 100644 randomx/configuration.h create mode 100644 randomx/cpu.cpp create mode 100644 randomx/cpu.hpp create mode 100644 randomx/dataset.cpp create mode 100644 randomx/dataset.hpp create mode 100644 randomx/instruction.cpp create mode 100644 randomx/instruction.hpp create mode 100644 randomx/instruction_weights.hpp create mode 100644 randomx/instructions_portable.cpp create mode 100644 randomx/intrin_portable.h create mode 100644 randomx/jit_compiler.hpp create mode 100644 randomx/jit_compiler_fallback.hpp create mode 100644 randomx/jit_compiler_x86.cpp create mode 100644 randomx/jit_compiler_x86.hpp create mode 100644 randomx/jit_compiler_x86_static.S create mode 100644 randomx/jit_compiler_x86_static.asm create mode 100644 randomx/jit_compiler_x86_static.hpp create mode 100644 randomx/mingw-std-threads-master/CMakeLists.txt create mode 100644 randomx/mingw-std-threads-master/LICENSE create mode 100644 randomx/mingw-std-threads-master/README.md create mode 100644 randomx/mingw-std-threads-master/cmake_stdheaders_generator/CMakeLists.txt create mode 100644 randomx/mingw-std-threads-master/cmake_stdheaders_generator/template.cpp create mode 100644 randomx/mingw-std-threads-master/mingw.condition_variable.h create mode 100644 randomx/mingw-std-threads-master/mingw.future.h create mode 100644 randomx/mingw-std-threads-master/mingw.invoke.h create mode 100644 randomx/mingw-std-threads-master/mingw.mutex.h create mode 100644 randomx/mingw-std-threads-master/mingw.shared_mutex.h create mode 100644 randomx/mingw-std-threads-master/mingw.thread.h create mode 100644 randomx/mingw-std-threads-master/tests/CMakeLists.txt create mode 100644 randomx/mingw-std-threads-master/tests/tests.cpp create mode 100644 randomx/mingw-std-threads-master/utility_scripts/Generate-StdLikeHeaders.ps1 create mode 100644 randomx/mingw-std-threads-master/utility_scripts/generate_std_like_headers.bat create mode 100644 randomx/mingw-std-threads-master/utility_scripts/generate_std_like_headers_interactive.bat create mode 100644 randomx/program.hpp create mode 100644 randomx/randomx.cpp create mode 100644 randomx/randomx.h create mode 100644 randomx/reciprocal.c create mode 100644 randomx/reciprocal.h create mode 100644 randomx/soft_aes.cpp create mode 100644 randomx/soft_aes.h create mode 100644 randomx/superscalar.cpp create mode 100644 randomx/superscalar.hpp create mode 100644 randomx/superscalar_program.hpp create mode 100644 randomx/virtual_machine.cpp create mode 100644 randomx/virtual_machine.hpp create mode 100644 randomx/virtual_memory.cpp create mode 100644 randomx/virtual_memory.hpp create mode 100644 randomx/vm_compiled.cpp create mode 100644 randomx/vm_compiled.hpp create mode 100644 randomx/vm_compiled_light.cpp create mode 100644 randomx/vm_compiled_light.hpp create mode 100644 randomx/vm_interpreted.cpp create mode 100644 randomx/vm_interpreted.hpp create mode 100644 randomx/vm_interpreted_light.cpp create mode 100644 randomx/vm_interpreted_light.hpp create mode 100644 sha3x/sha3x.c create mode 100644 sha3x/sha3x.h diff --git a/README.md b/README.md index e69de29..16b4196 100644 --- a/README.md +++ b/README.md @@ -0,0 +1,9 @@ +#矿池算法文件 +``` +编译命令(gcc编译器，ubuntu系统) +blake2b: +sha3x: +blake3: +heavyHash: +randomx: +``` \ No newline at end of file diff --git a/blake2b/blake2b.c b/blake2b/blake2b.c new file mode 100644 index 0000000..452d7ab --- /dev/null +++ b/blake2b/blake2b.c @@ -0,0 +1,237 @@ +#include +#include +#include +#include "blake2b.h" + +#ifndef ROTR64 +#define ROTR64(x, y) (((x) >> (y)) ^ ((x) << (64 - (y)))) +#endif +// Little-endian byte access. +#define B2B_GET64(p) \ +(((uint64_t) ((uint8_t *) (p))[0]) ^ \ +(((uint64_t) ((uint8_t *) (p))[1]) << 8) ^ \ +(((uint64_t) ((uint8_t *) (p))[2]) << 16) ^ \ +(((uint64_t) ((uint8_t *) (p))[3]) << 24) ^ \ +(((uint64_t) ((uint8_t *) (p))[4]) << 32) ^ \ +(((uint64_t) ((uint8_t *) (p))[5]) << 40) ^ \ +(((uint64_t) ((uint8_t *) (p))[6]) << 48) ^ \ +(((uint64_t) ((uint8_t *) (p))[7]) << 56)) +// G Mixing function. +#define B2B_G(a, b, c, d, x, y) { \ +v[a] = v[a] + v[b] + x; \ +v[d] = ROTR64(v[d] ^ v[a], 32); \ +v[c] = v[c] + v[d]; \ +v[b] = ROTR64(v[b] ^ v[c], 24); \ +v[a] = v[a] + v[b] + y; \ +v[d] = ROTR64(v[d] ^ v[a], 16); \ +v[c] = v[c] + v[d]; \ +v[b] = ROTR64(v[b] ^ v[c], 63); \ +} +// Initialization Vector. +static const uint64_t blake2b_iv[8] = { + 0x6A09E667F3BCC908, 0xBB67AE8584CAA73B, + 0x3C6EF372FE94F82B, 0xA54FF53A5F1D36F1, + 0x510E527FADE682D1, 0x9B05688C2B3E6C1F, + 0x1F83D9ABFB41BD6B, 0x5BE0CD19137E2179 +}; + +unsigned int be32toh(unsigned int x) +{ + return (((x & 0xff000000U) >> 24) | ((x & 0x00ff0000U) >> 8) | + ((x & 0x0000ff00U) << 8) | ((x & 0x000000ffU) << 24)); +} + +static void blake2b_compress(blake2b_ctx *ctx, int last) +{ + const uint8_t sigma[12][16] = { + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }, + { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }, + { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 }, + { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 }, + { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 }, + { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 }, + { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 }, + { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 }, + { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 }, + { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 }, + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }, + { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 } + }; +int i; +uint64_t v[16], m[16]; +//long int v15; +for (i = 0; i < 8; i++) { // init work variables + v[i] = ctx->h[i]; + v[i + 8] = blake2b_iv[i]; +} +//v15= v[15]; +//printf("the v15=%02lx\n" ,v15); + +v[12] ^= ctx->t[0]; // low 64 bits of offset +v[13] ^= ctx->t[1]; // high 64 bits + +//printf("ctx->t[0]= %016llx\n",ctx->t[0]); +//printf("ctx->t[1]= %016llx\n",ctx->t[1]); + +if (last) // last block flag set ? + v[14] = ~v[14]; + +for (i = 0; i < 16; i++) // get little-endian words + m[i] = B2B_GET64(&ctx->b[8 * i]); + +//for (int i = 0; i < 16; ++i) printf("v[%0d]=%016llx\n", i,v[i]); +//for (int i = 0; i < 16; ++i) printf("m[%0d]=%016llx\n", i,m[i]); + +for (i = 0; i < 12; i++) { // twelve rounds for (i = 0; i < 12; i++) { // twelve rounds + //printf("i=%0d\n",i); + //for (int i = 0; i < 16; ++i) printf("v[%0d]=%016llx\n", i,v[i]); + //for (int i = 0; i < 16; ++i) printf("m[%0d]=%016llx\n", i,m[i]); + + B2B_G( 0, 4, 8, 12, m[sigma[i][ 0]], m[sigma[i][ 1]]); + B2B_G( 1, 5, 9, 13, m[sigma[i][ 2]], m[sigma[i][ 3]]); + B2B_G( 2, 6, 10, 14, m[sigma[i][ 4]], m[sigma[i][ 5]]); + B2B_G( 3, 7, 11, 15, m[sigma[i][ 6]], m[sigma[i][ 7]]); + B2B_G( 0, 5, 10, 15, m[sigma[i][ 8]], m[sigma[i][ 9]]); + B2B_G( 1, 6, 11, 12, m[sigma[i][10]], m[sigma[i][11]]); + B2B_G( 2, 7, 8, 13, m[sigma[i][12]], m[sigma[i][13]]); + B2B_G( 3, 4, 9, 14, m[sigma[i][14]], m[sigma[i][15]]); + + } + //for (int i = 0; i < 16; ++i) printf("v[%0d]=%016llx\n", i,v[i]); +//v15= v[15]; +//printf("the v15=%02lx\n" ,v15); +for( i = 0; i < 8; ++i ) + ctx->h[i] ^= v[i] ^ v[i + 8]; +//v15= v[15]; +//printf("the v15=%02lx\n" ,v15); +} + +void blake2b_update(blake2b_ctx *ctx, const void *in, size_t inlen) // data bytes +{ +size_t i; +for (i = 0; i < inlen; i++) { + if (ctx->c == 128) { // buffer full ? + ctx->t[0] += ctx->c; // add counters + if (ctx->t[0] < ctx->c) // carry overflow ? + ctx->t[1]++; // high word + blake2b_compress(ctx, 0); // compress (not last) + ctx->c = 0; // counter to zero + //for (int i = 0; i < 8; ++i) printf("ctx->h[%0d]=%016llx\n",i,ctx->h[i]); + } + ctx->b[ctx->c++] = ((const uint8_t *) in)[i]; + } +/* +int t0,t1; +t0 = ctx->t[0]; +t1 = ctx->t[1]; +printf("the t[0]=%02x,the t[1]=%02x\n", t0,t1); +*/ + //printf("the t[0]=%02x,the t[1]=%02x\n", ctx->t[0],ctx->t[1]); +} + +int blake2b_init(blake2b_ctx *ctx, size_t outlen) // (keylen=0: no key) +{ +//size_t i; + +//if (outlen == 0 || outlen > 64 || keylen > 64) +// return -1; // illegal parameters +// +//for (i = 0; i < 8; i++) // state, "param block" +// ctx->h[i] = blake2b_iv[i]; +// +// ctx->h[0] ^= 0x01010000 ^ (keylen << 8) ^ outlen; +// ctx->t[0] = 0; // input count low word +// ctx->t[1] = 0; // input count high word +// ctx->c = 0; // pointer within buffer +// ctx->outlen = outlen; +// +//for (i = keylen; i < 128; i++) // zero input block +// ctx->b[i] = 0; +//if (keylen > 0) { +// blake2b_update(ctx, key, keylen); +// ctx->c = 128; // at the end +// } +ctx->h[0]= 0x6a09e667f2bdc93a; +ctx->h[1]= 0xbb67ae8584caa73b; +ctx->h[2]= 0x3c6ef372fe94f82b; +ctx->h[3]= 0xa54ff53a5f1d36f1; +ctx->h[4]= 0x510e527fade682d1; +ctx->h[5]= 0x9b05688c2b3e6c1f; +ctx->h[6]= 0x48ec89c38820de31; +ctx->h[7]= 0x5be0cd10137e21b1; +ctx->t[0] = 0; // input count low word +ctx->t[1] = 0; // input count high word +ctx->c = 0; // pointer within buffer +ctx->outlen = outlen; +return 0; +} + +void blake2b_final(blake2b_ctx *ctx, void *out) +{ +size_t i; +ctx->t[0] += ctx->c; // mark last block offset +if (ctx->t[0] < ctx->c) // carry overflow + ctx->t[1]++; // high word +while (ctx->c < 128) // fill up with zeros + ctx->b[ctx->c++] = 0; +//printf("the msg is :\n"); +//for (int i = 0; i < 128; ++i) printf("%02x",ctx->b[i]); +//printf("\n"); +blake2b_compress(ctx, 1); // final block flag = 1 +// little endian convert and store +/* +int t0,t1; +t0 = ctx->t[0]; +t1 = ctx->t[1]; +printf("the t[0]=%02x,the t[1]=%02x\n", t0,t1); +*/ +//for (i = 0; i < 128; i++) +// ((uint8_t *) msg_s1)[i] = ctx->b[i]; +//for (int i = 0; i < 8; ++i) printf("ctx->h[%0d]=%016llx\n",i,ctx->h[i]); +//printf("ctx->outlen= %0d\n",ctx->outlen ); +for (i = 0; i < ctx->outlen; i++) { + ((uint8_t *) out)[i] = (ctx->h[i >> 3] >> (8 * (i & 7))) & 0xFF; +} +} + +/* +int blake2b(void *out, size_t outlen,const void *key, size_t keylen,const void *in, size_t inlen,void *msg_s1) +{ + blake2b_ctx ctx; + if (blake2b_init(&ctx, outlen, key, keylen)) + return -1; + blake2b_update(&ctx, in, inlen); + blake2b_final(&ctx, out); + return 0; +} + +int main(int argc, char** argv) { +int i,j; +uint8_t md[50]; +uint8_t msg_s1[128]; + +uint8_t in[140+4] = { + 0x04,0x00,0x00,0x00, + 0xe5,0x4c,0x27,0x54,0x40,0x50,0x66,0x8f,0x27,0x2e,0xc3,0xb4,0x60,0xe1,0xcd,0xe7, + 0x45,0xc6,0xb2,0x12,0x39,0xa8,0x1d,0xae,0x63,0x7f,0xde,0x47,0x04,0x00,0x00,0x00, + 0x84,0x4b,0xc0,0xc5,0x56,0x96,0xef,0x99,0x20,0xee,0xda,0x11,0xc1,0xeb,0x41,0xb0, + 0xc2,0xe7,0x32,0x4b,0x46,0xcc,0x2e,0x7a,0xa0,0xc2,0xaa,0x77,0x36,0x44,0x8d,0x7a, + 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, + 0x68,0x24,0x1a,0x58, + 0x7e,0x7e,0x06,0x1d, + 0x25,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x01,0x00,0x00,0x00 + }; + +blake2b(md, 50, NULL, 0, in, sizeof(in), msg_s1); + +printf("the hash out is \n"); +for (i=0; i < sizeof(md); ++i) { + printf("%02x",md[i]); +} +printf("\n"); +return 0; +} +*/ \ No newline at end of file diff --git a/blake2b/blake2b.h b/blake2b/blake2b.h new file mode 100644 index 0000000..f1b2276 --- /dev/null +++ b/blake2b/blake2b.h @@ -0,0 +1,24 @@ +#include +#include + + +enum blake2b_constant +{ + BLAKE2B_BLOCKBYTES = 128, + BLAKE2B_OUTBYTES = 64, + BLAKE2B_KEYBYTES = 64, + BLAKE2B_SALTBYTES = 16, + BLAKE2B_PERSONALBYTES = 16 +}; + +typedef struct { + uint8_t b[128]; // input buffer + uint64_t h[8]; // chained state + uint64_t t[2]; // total number of bytes + size_t c; // pointer for b[] + size_t outlen; // digest size +} blake2b_ctx; + +void blake2b_update(blake2b_ctx *ctx, const void *in, size_t inlen); +int blake2b_init(blake2b_ctx *ctx, size_t outlen); +void blake2b_final(blake2b_ctx *ctx, void *out); \ No newline at end of file diff --git a/heavyHash/DiagonalMatrix.h b/heavyHash/DiagonalMatrix.h new file mode 100644 index 0000000..6a0634c --- /dev/null +++ b/heavyHash/DiagonalMatrix.h @@ -0,0 +1,192 @@ +#ifndef _SINGULAR_DIAGONAL_MATRIX_H +#define _SINGULAR_DIAGONAL_MATRIX_H + +#include "singular.h" + + + +//#define L(M,N) (M < N ? M : N) +#define L(M,N) (M*N) +#if 1 + +typedef struct class_DiagonalMatrix DiagonalMatrix_t; +struct class_DiagonalMatrix { + double *pBlock; + + double (*operator)(struct class_DiagonalMatrix *p, int i, int j); + void (*release)(struct class_DiagonalMatrix *p); +}; + +#else +#include +#include +#include + +//namespace singular { + + /** + * Diagonal matrix. + */ + template < int M, int N > + class DiagonalMatrix { + public: + enum { + /** Number of diagonal elements. */ + L = M < N ? M : N + }; + private: + /** + * Memory block for the diagonal elements. + * The ith row and ith column is given by `elements[i]`. + */ + double* pBlock; + public: + /** Initializes a diagonal matrix filled with 0. */ + DiagonalMatrix() { + this->pBlock = new double[L]; + std::fill(this->pBlock, this->pBlock + L, 0.0); + } + + /** + * Initializes a diagonal matrix with given diagonal values. + * + * The diagonal matrix will look like, + * \f[ + * \begin{bmatrix} + * \text{values[0]} & & \\ + * & \ddots & \\ + * & & \text{values[min(M, N)-1]} + * \end{bmatrix} + * \f] + * + * The behavior is undefined if `values` has less than `min(M, N)` + * elements. + * + * @param values + * Diagonal values of the matrix. + */ + explicit DiagonalMatrix(const double values[]) { + this->pBlock = new double[L]; + memcpy(this->pBlock, values, sizeof(double) * L); + } + + /** + * Steals the memory block from a given diagonal matrix. + * + * @param[in,out] copyee + * Diagonal matrix from which the memory block is to be stolen. + * No loger valid after this call. + */ +#if SINGULAR_RVALUE_REFERENCE_SUPPORTED + DiagonalMatrix(DiagonalMatrix&& copyee) : pBlock(copyee.pBlock) { + copyee.pBlock = nullptr; + } +#else + DiagonalMatrix(const DiagonalMatrix& copyee) : pBlock(copyee.pBlock) { + const_cast< DiagonalMatrix& >(copyee).pBlock = nullptr; + } +#endif + + /** Releases the memory block of this diagonal matrix. */ + ~DiagonalMatrix() { + this->release(); + } + + /** + * Steals the memory block from a given diagonal matrix. + * + * @param[in,out] copyee + * Diagonal matrix from which the memory block is to be stolen. + * No longer valid after this call. + * @return + * Reference to this diagonal matrix. + */ +#if SINGULAR_RVALUE_REFERENCE_SUPPORTED + DiagonalMatrix& operator =(DiagonalMatrix&& copyee) { +#else + DiagonalMatrix& operator =(const DiagonalMatrix& copyee) { +#endif + this->release(); + this->pBlock = copyee.pBlock; +#if SINGULAR_RVALUE_REFERENCE_SUPPORTED + copyee.pBlock = nullptr; +#else + const_cast< DiagonalMatrix& >(copyee).pBlock = nullptr; +#endif + return *this; + } + + /** + * Returns a clone of this matrix. + * + * @return + * Clone of this matrix. + */ + inline DiagonalMatrix clone() const { + return DiagonalMatrix(this->pBlock); + } + + /** + * Returns the element at a given row and column. + * + * The behavior is undefined, + * - if `i < 0` or `i >= M`, + * - or if `j < 0` or `j >= N` + * + * @param i + * Index of the row to be obtained. + * @param j + * Index of the column to be obtained. + * @return + * Element at the ith row and jth column. + * 0 if `i != j`. + */ + double operator ()(int i, int j) const { + assert(i >= 0 && i < M); + assert(j >= 0 && j < N); + if (i == j) { + return this->pBlock[i]; + } else { + return 0.0; + } + } + + /** + * Transposes this matrix. + * + * @return + * Transposed matrix. + */ + DiagonalMatrix< N, M > transpose() const { + return DiagonalMatrix< N, M >(this->pBlock); + } + private: +#if SINGULAR_FUNCTION_DELETION_SUPPORTED + /** Copy constructor is not allowed. */ + DiagonalMatrix(const DiagonalMatrix& copyee) = delete; + + /** Copy assignment is not allowed. */ + DiagonalMatrix& operator =(const DiagonalMatrix& copyee) = delete; +#elif SINGULAR_RVALUE_REFERENCE_SUPPORTED + /** Copy constructor is not allowed. */ + DiagonalMatrix(const DiagonalMatrix& copyee) {} + + /** Copy assignment is not allowed. */ + DiagonalMatrix& operator =(const DiagonalMatrix& copyee) { + return *this; + } +#endif + + /** + * Releases the memory block of this matrix. + * Has no effect if the memory block has already been released. + */ + inline void release() { + delete[] this->pBlock; + this->pBlock = nullptr; + } + }; + +//} +#endif +#endif diff --git a/heavyHash/Makefile b/heavyHash/Makefile new file mode 100644 index 0000000..ddc449a --- /dev/null +++ b/heavyHash/Makefile @@ -0,0 +1,14 @@ +SRCS = heavyhash.c obtc.c sha3.c + +OBJS = $(SRCS:.c=.o) +CC = gcc +CCFLAGS = -Wall + +libkas.a:$(OBJS) + ar -rv libkas.a $(OBJS) + +%.o:%.c + $(CC) $(CCFLAGS) -c $< -o $@ + +clean: + rm -rf *.o *.a diff --git a/heavyHash/Matrix.h b/heavyHash/Matrix.h new file mode 100644 index 0000000..377fa48 --- /dev/null +++ b/heavyHash/Matrix.h @@ -0,0 +1,25 @@ +#ifndef _SINGULAR_MATRIX_H +#define _SINGULAR_MATRIX_H + +#include "singular.h" +#include "Vector.h" + +//#include +//#include +//#include + + +typedef struct class_Matrix Matrix_t; +struct class_Matrix { + double* pBlock; + + Matrix_t (*clone)(struct class_Matrix *p); + void (*filledwith)(struct class_Matrix *p,const double values[]); + double (*operator)(struct class_Matrix *p, int i, int j); + Vector_t (*row)(struct class_Matrix *p, int i); + Vector_t (*column)(struct class_Matrix *p, int j); + void (*release)(struct class_Matrix *p); +}; + + +#endif diff --git a/heavyHash/Reflector.h b/heavyHash/Reflector.h new file mode 100644 index 0000000..fc9042b --- /dev/null +++ b/heavyHash/Reflector.h @@ -0,0 +1,19 @@ +#ifndef _SINGULAR_REFLECTOR_H +#define _SINGULAR_REFLECTOR_H + +#include "Matrix.h" +#include "singular.h" + + + +typedef struct class_Reflector Reflector_t; +struct class_Reflector { + Vector_t u; + double gamma; + size_t L; + + double* ptr; +}; + + +#endif diff --git a/heavyHash/Rotator.h b/heavyHash/Rotator.h new file mode 100644 index 0000000..03047d7 --- /dev/null +++ b/heavyHash/Rotator.h @@ -0,0 +1,17 @@ +#ifndef _SINGULAR_ROTATOR_H +#define _SINGULAR_ROTATOR_H + +#include "Matrix.h" +#include "singular.h" + + +typedef struct class_Rotator Rotator_t; +struct class_Rotator { + double elements[4]; + double (*operator)(struct class_Rotator *p, int i, int j); + void (*applyFromLeftTo)(struct class_Rotator *p, Matrix_t rhs, int k); + void (*applyFromRightTo)(struct class_Rotator *p, Matrix_t rhs, int k); +}; + + +#endif diff --git a/heavyHash/Svd.h b/heavyHash/Svd.h new file mode 100644 index 0000000..a070917 --- /dev/null +++ b/heavyHash/Svd.h @@ -0,0 +1,45 @@ +#ifndef _SINGULAR_SVD_H +#define _SINGULAR_SVD_H + +#include "DiagonalMatrix.h" +#include "Matrix.h" +#include "Reflector.h" +#include "Rotator.h" +//#include "singular.h" + +//#include +//#include +//#include + +typedef struct Svd Svd_t; +struct Svd { + //USV decomposeUSV(const Matrix< M, N >& m) + bool (*isFullRank)(Svd_t *p, DiagonalMatrix_t singularValues, const int size); +}; + +typedef struct class_BidiagonalMatrix BidiagonalMatrix_t; +struct class_BidiagonalMatrix { + double* pBlock; + double (*operator)(struct class_BidiagonalMatrix *p, int i, int j); + double (*applyFirstRotatorFromRight)(struct class_BidiagonalMatrix *p, Rotator_t *r); + double (*applyRotatorFromRight)(struct class_BidiagonalMatrix *p, Rotator_t *r, int n, double bulge); + double (*applyRotatorFromLeft)(struct class_BidiagonalMatrix *p, Rotator_t *r, int n, double bulge); + BidiagonalMatrix_t (*bidiagonalize)(struct class_BidiagonalMatrix *p, Matrix_t m); + void (*doFrancis)(struct class_BidiagonalMatrix *m,int n); + double (*calculateShift)(struct class_BidiagonalMatrix *m, int n); + void (*releases)(struct class_BidiagonalMatrix *p); +}; + +void BidiagonalMatrix_doFrancis(BidiagonalMatrix_t *m, int n); +double BidiagonalMatrix_calculateShift(BidiagonalMatrix_t *m, int n); +double BidiagonalMatrix_applyRotatorFromLeft(BidiagonalMatrix_t *ptr, Rotator_t *r, int n, double bulge); +double BidiagonalMatrix_applyRotatorFromRight(BidiagonalMatrix_t *ptr, Rotator_t *r, int n, double bulge); +double BidiagonalMatrix_applyFirstRotatorFromRight(BidiagonalMatrix_t *p, Rotator_t *r); +double BidiagonalMatrix_operator(BidiagonalMatrix_t *p, int i, int j); +void BidiagonalMatrix_release(BidiagonalMatrix_t *p); +void BidiagonalMatrix_init(BidiagonalMatrix_t *p, Matrix_t *m); +void BidiagonalMatrix_def(BidiagonalMatrix_t *p); +BidiagonalMatrix_t BidiagonalMatrix_bidiagonalize(BidiagonalMatrix_t *p, Matrix_t m); + + +#endif diff --git a/heavyHash/Vector.h b/heavyHash/Vector.h new file mode 100644 index 0000000..458ceb6 --- /dev/null +++ b/heavyHash/Vector.h @@ -0,0 +1,22 @@ +#ifndef _SINGULAR_VECTOR_H +#define _SINGULAR_VECTOR_H + + +#include +#include "singular.h" + + +typedef struct class_Vector Vector_t; +struct class_Vector { + double* pBlock; + size_t len; + ptrdiff_t delta; + + double* ptr; + void (*move)(struct class_Vector *p, ptrdiff_t delta); + double (*operator)(struct class_Vector *p, size_t idx); + Vector_t (*slice)(struct class_Vector *p, size_t start); +}; + + +#endif diff --git a/heavyHash/heavyhash.c b/heavyHash/heavyhash.c new file mode 100644 index 0000000..13fce9d --- /dev/null +++ b/heavyHash/heavyhash.c @@ -0,0 +1,150 @@ +#include "sha3.h" +#include "obtc.h" + + + + +void CSHA3_256_Write(CSHA3_256 *p, const unsigned char* data, size_t len) { + sha3_update(&p->context, data, len); + //return *this; +} + +void CSHA3_256_Finalize(CSHA3_256 *p, unsigned char hash[OUTPUT_SIZE]) { + sha3_final(hash, &p->context); +} + +/*void CSHA3_256_Reset(Obtc_t *Obtc, CSHA3_256 *p) { + sha3_init(Obtc,&p->context, OUTPUT_SIZE); + //return *this; +}*/ + +void CSHA3_256_init(Obtc_t *Obtc, CSHA3_256 *p) { + + sha3_init(Obtc, &p->context, OUTPUT_SIZE); + + p->Write = CSHA3_256_Write; + p->Finalize = CSHA3_256_Finalize; + //p->Reset = CSHA3_256_Reset; +} + +void CSHA3_256_CSHA3_256(Obtc_t *Obtc,CSHA3_256 *p) { + sha3_init(Obtc,&p->context, OUTPUT_SIZE); + +} + + +void CHeavyHash_Write(CHeavyHash *p, const unsigned char* data, size_t len) { + p->hasher.Write(&p->hasher,data, len); + //sha3_update(&CSHA3_256_p.context, data, len); + //CSHA3_256_Write(&CSHA3_256_p, data, OUTPUT_SIZE); + } + +void CHeavyHash_Finalize(Obtc_t *Obtc, CHeavyHash *p, unsigned char hash[OUTPUT_SIZE]) { + uint256 hash_first; + uint8_t a[32]; + + p->hasher.Finalize(&p->hasher,&Obtc->g_hash_first.bb.data[0]); + memcpy(a,&Obtc->g_hash_first.bb.data[0],32); + + uint256 product = MultiplyUsing4bitPrecision(p->matrix, Obtc->g_hash_first); + + uint256 hash_xored; + for (size_t i = 0; i < OUTPUT_SIZE; ++i) { + //hash_xored.begin()[i] = hash_first.begin()[i] ^ product.begin()[i]; + hash_xored.bb.data[i] = Obtc->g_hash_first.bb.data[i] ^ product.bb.data[i]; + + + } + + uint8_t temp[200]={ + 0x16,0x19,0x32,0x7d,0x10,0xb9,0xda,0x35,0x54,0x9a,0xe0,0x31,0x2f,0x9f,0xc6,0x15,0x92,0xbb,0x39,0x9d, + 0xb5,0x29,0x0c,0x0a,0x47,0xc3,0x9f,0x67,0x51,0x12,0xc2,0x2e,0xc7,0x76,0xc5,0x04,0x84,0x81,0xb9,0x57, + 0xb9,0x92,0xf2,0xd3,0x7b,0x34,0xca,0x58,0xea,0x8f,0xdb,0x80,0xba,0xc4,0x6d,0x39,0x7e,0x8f,0x1d,0xb1, + 0x77,0x65,0xcc,0x07,0x87,0xe9,0x61,0xb0,0x36,0xbc,0x94,0x16,0x77,0x4c,0x86,0x83,0x54,0x34,0xf2,0xb0, + 0x4e,0xf7,0x4b,0x3a,0x99,0xcd,0xb0,0x44,0x2e,0xc6,0x5b,0xd3,0x56,0x24,0x93,0xe4,0x6c,0x6b,0x7d,0x01, + 0xa7,0x69,0xcc,0x3d,0xd3,0x1f,0x4c,0xc3,0x54,0xc1,0x8c,0x3f,0xf4,0x31,0xc0,0x5d,0xd0,0xa9,0xa2,0x26, + 0xa0,0xbc,0xaa,0x9f,0x79,0x2a,0x3d,0x0c,0x80,0x39,0xf9,0xa6,0x0d,0xcf,0x6a,0x48,0x5e,0x21,0x90,0x40, + 0x25,0x0f,0xc4,0x62,0xc1,0x00,0xff,0x2a,0x93,0x89,0x35,0xba,0x72,0xc7,0xd8,0x2e,0x14,0xf3,0x40,0x69, + 0xe7,0x20,0xe0,0xdf,0x44,0xee,0xce,0xde,0x11,0xa7,0x5f,0x4c,0x80,0x05,0x64,0x98,0x7a,0x14,0xff,0x48, + 0x16,0xc7,0xf8,0xee,0x79,0x62,0x9b,0x0e,0x2f,0x9f,0x42,0x16,0x3a,0xd7,0x4c,0x52,0xb2,0x24,0x85,0x09, + }; + for(int i = 0 ;i< 200 ;i++)Obtc->const_data[i] = temp[i]; + + // CSHA3_256().Write(hash_xored.begin(), OUTPUT_SIZE).Finalize(hash); + + CSHA3_256_CSHA3_256(Obtc, &p->hasher); + CSHA3_256_Write(&p->hasher, &hash_xored.bb.data[0], OUTPUT_SIZE); + CSHA3_256_Finalize(&p->hasher, hash) ; +} + +void CHeavyHash_Reset(CHeavyHash *p, uint64_t matrix_[64*64]) { + for (int i = 0; i < 64*64; ++i) + p->matrix[i] = matrix_[i]; +} + +void CHeavyHash_init(Obtc_t *Obtc, CHeavyHash *p, uint64_t matrix_[64*64]){ + + p->Write = CHeavyHash_Write; + p->Finalize = CHeavyHash_Finalize; + p->Reset = CHeavyHash_Reset; + + p->hasher.Write = CSHA3_256_Write; + p->hasher.Finalize = CSHA3_256_Finalize; + //p->hasher.Reset = CSHA3_256_Reset; + + sha3_init(Obtc, &p->hasher.context, OUTPUT_SIZE); + + for (int i = 0; i < 64*64; ++i) + p->matrix[i] = matrix_[i]; + +} + + + + +void MultiplyMatrices(uint64_t matrix[64*64], uint64_t vector[64], uint64_t product[64]){ + for (int i = 0; i < 64; ++i) { + for (int j = 0; j < 64; ++j) { + product[i] += matrix[64*i + j]*vector[j]; + } + } +} + +uint256 MultiplyUsing4bitPrecision(uint64_t matrix[64*64], const uint256 hash) { + // conversion to matrix with 4 bit values + uint64_t vector[64] = {0}; + ConvertTo4BitPrecisionVector(hash, vector); + + // perform matrix multiplication + uint64_t product[64] = {0}; + MultiplyMatrices(matrix, vector, product); + for (int i = 0; i < 64; ++i) { + product[i] >>= 10; + } + return Convert4bitVectorToUint(product); +} + +void ConvertTo4BitPrecisionVector(uint256 bit_sequence, uint64_t vector[64]) { + int index = 0; + int i; + + for (i = 0; i < WIDTH; i++) { + + vector[index] = bit_sequence.bb.data[i] >> 4; + vector[index+1] = bit_sequence.bb.data[i] & 0xF; + index += 2; + } +} + +uint256 Convert4bitVectorToUint(const uint64_t x[64]) { + uint256 bit_sequence; + int index = 0; + int i; + + for (i = 0; i < WIDTH; i++) { + bit_sequence.bb.data[i] = ( x[index] << 4) | x[index+1]; + index += 2; + } + + return bit_sequence; +} diff --git a/heavyHash/heavyhash.h b/heavyHash/heavyhash.h new file mode 100644 index 0000000..9243c3f --- /dev/null +++ b/heavyHash/heavyhash.h @@ -0,0 +1,98 @@ +#ifndef OPOW_CRYPTO_HEAVYHASH_H +#define OPOW_CRYPTO_HEAVYHASH_H + +#include +#include +#include "sha3.h" + +//#include +//#include "obtc.h" + + +#define OUTPUT_SIZE 32 + +typedef struct class_CSHA3_256 CSHA3_256; + +struct class_CSHA3_256 +{ + sha3_ctx_t context; + + // static const size_t OUTPUT_SIZE = 32; + + //CSHA3_256& Write(const unsigned char* data, size_t len); + void (*Write)(struct class_CSHA3_256 *p, const unsigned char* data, size_t len); + void (*Finalize)(struct class_CSHA3_256 *p, unsigned char hash[OUTPUT_SIZE]); + //CSHA3_256& Reset(); +}; + + +typedef struct class_CHeavyHash CHeavyHash; +struct class_CHeavyHash +{ + + uint64_t matrix[64*64]; + CSHA3_256 hasher; + + //static const size_t OUTPUT_SIZE = 32; + //explicit CHeavyHash(uint64_t matrix_[64*64]); + //CHeavyHash& Reset(uint64_t matrix_[64*64]); + //CHeavyHash& Write(const unsigned char* data, size_t len); + //void Finalize(unsigned char hash[OUTPUT_SIZE]); + void (*Reset)(struct class_CHeavyHash *p, uint64_t matrix_[64*64]); + void (*Write)(struct class_CHeavyHash *p, const unsigned char* data, size_t len); + void (*Finalize)(struct class_CHeavyHash *p, unsigned char hash[OUTPUT_SIZE]); +}; + +#if 0 +/** A hasher class for SHA3-256. */ +class CSHA3_256 +{ +private: + sha3_ctx_t context; + +public: + static const size_t OUTPUT_SIZE = 32; + + CSHA3_256(); + CSHA3_256& Write(const unsigned char* data, size_t len); + void Finalize(unsigned char hash[OUTPUT_SIZE]); + CSHA3_256& Reset(); +}; + +class CHeavyHash +{ +private: + uint64_t matrix[64*64]; + CSHA3_256 hasher; + +public: + static const size_t OUTPUT_SIZE = 32; + explicit CHeavyHash(uint64_t matrix_[64*64]); + CHeavyHash& Reset(uint64_t matrix_[64*64]); + CHeavyHash& Write(const unsigned char* data, size_t len); + void Finalize(unsigned char hash[OUTPUT_SIZE]); +}; +#endif +uint256 MultiplyUsing4bitPrecision(uint64_t matrix[64*64], const uint256 hash); + +void ConvertTo4BitPrecisionVector(uint256 bit_sequence, uint64_t vector[64]); + +uint256 Convert4bitVectorToUint(const uint64_t x[64]); + + +//zzj add +/*extern void CSHA3_256_init(struct Obtc_opt *Obtc, CSHA3_256 *p); +void CSHA3_256_CSHA3_256(struct Obtc_opt *Obtc, CSHA3_256 *p); + +void CSHA3_256_Write(CSHA3_256 *p, const unsigned char* data, size_t len); + +void CSHA3_256_Finalize(CSHA3_256 *p, unsigned char hash[OUTPUT_SIZE]); +// + +void CHeavyHash_init(struct Obtc_opt *Obtc, CHeavyHash *p, uint64_t matrix_[64*64]); +void CHeavyHash_Write(CHeavyHash *p, const unsigned char* data, size_t len); + +void CHeavyHash_Finalize(struct Obtc_opt *Obtc, CHeavyHash *p, unsigned char hash[OUTPUT_SIZE]); +*/ + +#endif // OPOW_CRYPTO_HEAVYHASH_H diff --git a/heavyHash/heavyhash.o b/heavyHash/heavyhash.o new file mode 100644 index 0000000000000000000000000000000000000000..8e2ead9cfa33e25472d851f386e7e121a2e731bb GIT binary patch literal 5296 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 wV-FB1UG!H=KF*uAe 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 +#include +#include +#include //qsort +#include + +#include "obtc.h" + + +#define M 64 +#define N 64 + +bool Is4BitPrecision(const uint64_t matrix[64*64]) +{ + for (int i = 0; i < 64; ++i) { + for (int j = 0; j < 64; ++j) { + if (matrix[ i*64 + j] > 0xF) + return false; + } + } + return true; +} + + + + +double DiagonalMatrix_operator(DiagonalMatrix_t *p, int i, int j) +{ + assert(i >= 0 && i < 64); + assert(j >= 0 && j < 64); + if (i == j) { + return p->pBlock[i]; + } else { + return 0.0; + } +} + +void DiagonalMatrix_release(DiagonalMatrix_t *p) +{ + if (p->pBlock != NULL){ + free(p->pBlock); + p->pBlock = NULL; + } +} + +void DiagonalMatrix_init(DiagonalMatrix_t *p, const double values[]) +{ + p->pBlock = (double *)malloc(sizeof(double)*M); + //memset(pBlock, 0.0, sizeof(double)*L(64,64)); + memcpy(p->pBlock, values, sizeof(double) * M); + + p->operator = DiagonalMatrix_operator; + p->release = DiagonalMatrix_release; + +} + +void DiagonalMatrix_DiagonalMatrix(DiagonalMatrix_t *p) +{ + p->operator = DiagonalMatrix_operator; + p->release = DiagonalMatrix_release; +} + +//-----------------------------vector-------------------------------// + +void vector_move(Vector_t *p, ptrdiff_t delta) { + p->ptr += delta; +} + +Vector_t vector_slice(Vector_t v, size_t start) { + //assert(start >= 0 && start <= p->len); + Vector_t v_tmp; + v_tmp.pBlock = v.pBlock + start * v.delta; + v_tmp.len = v.len - start; + v_tmp.delta = v.delta; + return v_tmp; +} + +double Vector_column_operator(Vector_t *p, size_t idx){ + return p->pBlock[idx * p->delta]; +} + +double Vector_row_operator(Vector_t *p, size_t idx){ + return p->pBlock[idx * p->delta]; +} + +void Vector_sync(Matrix_t *p, size_t idx, Vector_t vec, int offset){ + for(int i = 0; i < vec.len; i++){ + p->pBlock[idx+(offset+i)*N] = vec.pBlock[i]; + } +} + +void Vector_row_sync(Matrix_t *p, size_t idx, Vector_t vec, int offset){ + for(int i = 0; i < vec.len; i++){ + p->pBlock[offset+idx*N+i] = vec.pBlock[i]; + } +} + + +//-----------------------------Martrix-------------------------------// +Matrix_t Matrix_clone(Matrix_t *p) +{ + Matrix_t m; + + m.pBlock = (double *)malloc(sizeof(double)*L(64,64)); + memcpy(m.pBlock, p->pBlock, sizeof(double)*L(64,64)); + + return m; +} + +void Matrix_filledwith(Matrix_t *p, const double values[]) +{ + //p->pBlock = (double *)malloc(sizeof(double)*L(64,64)); + //memset(pBlock, 0.0, sizeof(double)*L(64,64)); + memcpy(p->pBlock, values, sizeof(double) * L(64,64)); +} + +double Matrix_operator(Matrix_t *p, int i, int j) +{ + assert(i >= 0 && i < N); + assert(j >= 0 && j < N); + + return p->pBlock[i*N+j]; + +} + + + +Vector_t Matrix_row(Matrix_t *p, int i) +{ + Vector_t vec_tmp; + vec_tmp.len = N; + vec_tmp.delta = 1; + vec_tmp.pBlock = p->pBlock + i*N; + //return Vector< const double >(this->pBlock + i * N, N, 1); + return vec_tmp; + +} + +Vector_t Matrix_column(Matrix_t *p, int j) +{ + Vector_t vec_tmp; + vec_tmp.len = M; + vec_tmp.delta = N; + vec_tmp.pBlock = p->pBlock + j; + + return vec_tmp; + //return Vector< double >(this->pBlock + j, M, N); + +} + +void Matrix_release(Matrix_t *p) +{ + if (p->pBlock != NULL){ + free(p->pBlock); + p->pBlock = NULL; + } +} + +void Matrix_init(Matrix_t *p) +{ + p->pBlock = (double *)malloc(sizeof(double)*L(64,64)); + memset(p->pBlock, 0.0, sizeof(double)*L(64,64)); + //memcpy(p->pBlock, values, sizeof(double) * L(64,64)); +} + +void Matrix_def(Matrix_t *p) +{ + //p->clone = Matrix_clone; + p->filledwith = Matrix_filledwith; + p->operator = Matrix_operator; + p->row = Matrix_row; + p->column = Matrix_column; + p->release = Matrix_release; +} + + + + + + +//-----------------------------Rotator-------------------------------// + +double max(double a, double b) +{ + return a > b ? a : b; +} + +double Rotator_operator(Rotator_t *p, int i, int j){ + assert(0 <= i && i < 2); + assert(0 <= j && j < 2); + return p->elements[i * 2 + j]; +} + +void Rotator_init(Rotator_t *p, double x1, double x2) +{ + // normalizes by the maximum magnitude + // to avoid harmful underflow and overflow + double mx = max(fabs(x1), fabs(x2)); + + x1 /= mx; + x2 /= mx; + double norm = sqrt(x1 * x1 + x2 * x2); + double cs = x1 / norm; + double sn = x2 / norm; + p->elements[0] = cs; + p->elements[1] = -sn; + p->elements[2] = sn; + p->elements[3] = cs; + + p->operator = Rotator_operator; +} + +//-----------------------------Reflector-------------------------------// + + +void Reflector_transform(Reflector_t *p, double u0, size_t len){ + int i; + for (i = 0; i < len; i++){ + p->u.pBlock[i] = p->u.pBlock[i] /u0; + } +} + +void Reflector_transform_left(Reflector_t *src1, Vector_t src2, Vector_t dst, double gUM, size_t len){ + int i; + for (i = 0; i < len; i++){ + dst.pBlock[i] = src2.pBlock[i] - src1->u.pBlock[i] * gUM; + } +} + +void Reflector_transform_right(Reflector_t *src1, Vector_t src2, Vector_t dst, double gMU, size_t len){ + int i; + for (i = 0; i < len; i++){ + dst.pBlock[i] = src2.pBlock[i] - gMU * src1->u.pBlock[i]; + } +} + + + +void Reflector_init(Reflector_t *p, Vector_t v) { + //assert(v.size() > 0 && v.size() <= L); + //const size_t N = v.size(); + //const size_t p->L = sizeof(v)/sizeof(double); + p->L = v.len; + + p->u.pBlock = (double *)malloc(sizeof(double)*v.len); + memcpy(p->u.pBlock, v.pBlock, sizeof(double)*v.len); + + // normalizes elements by the maximum amplitude + // to avoid harmful underflow and overflow + + double mx = 0.0; + + for (size_t i = 0; i < p->L; ++i) { + mx = max(fabs(p->u.pBlock[i]), mx); + } + + if (mx > 0.0) { + // calculates the normalized norm + double tau = 0.0; + for (size_t i = 0; i < p->L; ++i) { + double x = p->u.pBlock[i] / mx; + p->u.pBlock[i] = x; + tau += x * x; + } + tau = sqrt(tau); + // tau's sign should be the same as the first element in `u` + if (p->u.pBlock[0] < 0.0) { + tau = -tau; + } + double u0 = p->u.pBlock[0] + tau; + p->u.pBlock[0] = u0; + Reflector_transform(p, u0, p->L); + + p->gamma = u0 / tau; + } else { + // v is a zero vector + p->gamma = 0.0; + memset(p->u.pBlock, 0.0, p->L); + } +} + +void Reflector_release(Reflector_t *p){ + if (p->u.pBlock != NULL){ + free(p->u.pBlock); + p->u.pBlock = NULL; + } +} + + +double inner_product(double *a,double *b,int n){ + int i; + double sum = 0.0; + + for(i = 0; i < n; i++) + { + sum += (*(a+i))*(*(b+i)); + } + return sum; +} + +Matrix_t Reflector_applyFromLeftTo(Reflector_t *p, Matrix_t m){ + // H * m = m - gamma * u * u^T * m + Matrix_t m2 = Matrix_clone(&m);//m->clone(m); + Vector_t vec_m; + Vector_t vec_m2; + + int offset = N - p->L; + for (int i = 0; i < N; ++i) { + // caches gamma * u^T * m + vec_m = Matrix_column(&m, i); + + Vector_t srcColumn = vector_slice(vec_m, offset); + double v_src_column[srcColumn.len]; + + for(size_t i = 0; i < srcColumn.len; i++){ + v_src_column[i] = Vector_column_operator(&srcColumn, i); + } + srcColumn.pBlock = v_src_column; + + double gUM = inner_product(p->u.pBlock, srcColumn.pBlock, p->L); + //Vector< const double > srcColumn = m->column(m, i).slice(offset); + + gUM *= p->gamma; + // H * m = m - u * gUM + vec_m2 = Matrix_column(&m2, i); + Vector_t dstColumn = vector_slice(vec_m2, offset); + double v_dstcolumn[dstColumn.len]; + + for(size_t i = 0; i < dstColumn.len; i++){ + v_dstcolumn[i] = Vector_column_operator(&dstColumn, i); + } + dstColumn.pBlock = v_dstcolumn; + + Reflector_transform_left(p, srcColumn, dstColumn, gUM, p->L); + Vector_sync(&m2, i, dstColumn, offset); + } + Matrix_release(&m); + return m2; +} + +Matrix_t Reflector_applyFromRightTo(Reflector_t *p, Matrix_t m){ + // m * H = m - m * gamma * u * u^T + Matrix_t m2 = Matrix_clone(&m); + Vector_t vec_m; + Vector_t vec_m2; + + int offset = 64 - p->L; + + for (int i = 0; i < M; ++i) { + // caches gamma * m * u + vec_m = Matrix_row(&m, i); + Vector_t srcRow = vector_slice(vec_m, offset); + + double v_src_row[srcRow.len]; + for(size_t j = 0; j< srcRow.len; j++){ + v_src_row[j] = Vector_row_operator(&srcRow, j); + } + srcRow.pBlock = v_src_row; + + double gMU = inner_product(p->u.pBlock, srcRow.pBlock, p->L); + + gMU *= p->gamma; + // m * H = m - gMU * u^T + vec_m2 = Matrix_row(&m2, i); + + Vector_t dstRow = vector_slice(vec_m2, offset); + + double v_dstrow[dstRow.len]; + + for(size_t j = 0; j < dstRow.len; j++){ + v_dstrow[j] = Vector_row_operator(&dstRow, j); + } + dstRow.pBlock = v_dstrow; + + Reflector_transform_right(p ,srcRow, dstRow, gMU, p->L); + Vector_row_sync(&m2, i, dstRow, offset); + } + Matrix_release(&m); + return m2; +} + + +//-----------------------------Svd-------------------------------// + +int cmp_double(const void* e1, const void* e2) +{ + if ((*(double*)e2 - *(double*)e1) > 0.00000) + return 1; + else if ((*(double*)e2 - *(double*)e1) == 0.000000) + return 0; + else + return -1; +} + +DiagonalMatrix_t Svd_decomposeUSV(BidiagonalMatrix_t *p, Matrix_t *m) { + const int MAX_ITERATIONS = N * 10; + // allocates matrices + Matrix_t m1 = Matrix_clone(m); + Matrix_def(&m1); + + + + // bidiagonalizes a given matrix + BidiagonalMatrix_t m2 = p->bidiagonalize(p, m1); + // repeats Francis iteration + + + int iteration = 0; + int n = N; + + while (n >= 2) { + // processes the n-1 x n-1 submatrix + // if the current n x n submatrix has converged + double bn = m2.operator(&m2, n - 1, n - 1); + + if (bn == 0.0 || fabs(m2.operator(&m2, n - 2, n - 1) / bn) < 1.0e-15) { + --n; + } else { + // aborts if too many iterations + ++iteration; + if (iteration > MAX_ITERATIONS) { + break; + } + m2.doFrancis(&m2, n); + } + } + + // copies the diagonal elements + // and makes all singular values positive + double ss[N]; + for (int i = 0; i < N; ++i) { + if (m2.operator(&m2, i, i) < 0) { + ss[i] = -m2.operator(&m2, i, i); + // inverts the sign of the right singular vector + //Vector< double > vi = v.column(i); + //std::transform( + // vi.begin(), vi.end(), vi.begin(), + // [](double x) { + // return -x; + // }); + } else { + ss[i] = m2.operator(&m2, i, i); + } + } + + // sorts singular values in descending order if necessary + int shuffle[M]; // M >= N + bool sortNeeded = false; + for (int i = 0; i < M; ++i) { + shuffle[i] = i; + sortNeeded = sortNeeded || (i < N - 1 && ss[i] < ss[i + 1]); + } + + m1.release(&m1); + BidiagonalMatrix_release(p); + + + DiagonalMatrix_t dm; + if (sortNeeded) { + // shuffles the N (<= M) singular values + qsort(ss, N,sizeof(double), cmp_double); + + double ss2[M]; + + memcpy(ss2, ss, M*sizeof(double)); + DiagonalMatrix_init(&dm, ss2); + + return dm; + } else { + DiagonalMatrix_init(&dm, ss); + return dm; + } +} + + + + +bool Svd_isFullRank(DiagonalMatrix_t *p, const int size) { + const double round_off = 1.000009e-12; + for (int i = 0; i < size; ++i) { + if (fabs( p->operator(p, i, i) ) < round_off){ + p->release(p); + return false; + } + } + p->release(p); + return true; +} + + +//-----------------------------BidiagonalMatrix_t-------------------------------// +BidiagonalMatrix_t BidiagonalMatrix_bidiagonalize(BidiagonalMatrix_t *p, Matrix_t m) +{ + assert(M >= N); + + Vector_t vec_m; + Vector_t vec_m2; + + for (int i = 0; i < N; ++i) { + Reflector_t rU; + + vec_m = Matrix_column(&m, i); + Vector_t column_slice = vector_slice(vec_m, i); + // applies a householder transform to the column vector i + + double v_column[column_slice.len]; + + for(size_t i = 0; i < column_slice.len; i++){ + v_column[i] = Vector_column_operator(&column_slice, i); + } + column_slice.pBlock = v_column; + + Reflector_init(&rU, column_slice); + + m = Reflector_applyFromLeftTo(&rU, m); + + Reflector_release(&rU); + //u = rU.applyFromRightTo(u); // U1^T*U0^T = U0*U1 + if (i < N - 1) { + // applies a householder transform to the row vector i + 1 + //Reflector< N > rV(m.row(i).slice(i + 1)); + Reflector_t rV; + vec_m2 = Matrix_row(&m, i); + Vector_t row_slice = vector_slice(vec_m2, i+1); + + double v_row[row_slice.len]; + + for(size_t i = 0; i < row_slice.len; i++){ + v_row[i] = Vector_row_operator(&row_slice, i); + } + row_slice.pBlock = v_row; + Reflector_init(&rV, row_slice); + + m = Reflector_applyFromRightTo(&rV, m); + //m = rV.applyFromRightTo(m); + //v = rV.applyFromRightTo(v); + + Reflector_release(&rV); + + } + } + + BidiagonalMatrix_init(p, &m); + return *p; +} + +void BidiagonalMatrix_release(BidiagonalMatrix_t *p) +{ + if (p->pBlock != NULL){ + free(p->pBlock); + p->pBlock = NULL; + } +} + +double BidiagonalMatrix_operator(BidiagonalMatrix_t *p, int i, int j) +{ + assert(i >= 0 && i < M); + assert(j >= 0 && j < N); + if (i == j) { + return p->pBlock[2 * i]; + } else if (i + 1 == j) { + return p->pBlock[2 * i + 1]; + } else { + return 0.0; + } + +} + +double BidiagonalMatrix_applyFirstRotatorFromRight(BidiagonalMatrix_t *p, Rotator_t *r) +{ + double b1 = p->pBlock[0]; + double g1 = p->pBlock[1]; + double b2 = p->pBlock[2]; + double r11 = Rotator_operator(r, 0, 0);//r->operator(r, 0, 0); + double r12 = Rotator_operator(r, 0, 1);//r->operator(r, 0, 1); + double r21 = Rotator_operator(r, 1, 0);//r->operator(r, 1, 0); + double r22 = Rotator_operator(r, 1, 1);//r->operator(r, 1, 1); + //Rotator_operator + + p->pBlock[0] = b1 * r11 + g1 * r21; + p->pBlock[1] = b1 * r12 + g1 * r22; + p->pBlock[2] = b2 * r22; + return b2 * r21; +} + +double BidiagonalMatrix_applyRotatorFromRight(BidiagonalMatrix_t *ptr, Rotator_t *r, int n, double bulge) +{ + double* p = ptr->pBlock + n * 2; + double g0 = p[-1]; + double b1 = p[0]; + double g1 = p[1]; + double b2 = p[2]; + double r11 = r->operator(r, 0, 0); + double r12 = r->operator(r, 0, 1); + double r21 = r->operator(r, 1, 0); + double r22 = r->operator(r, 1, 1); + p[-1] = g0 * r11 + bulge * r21; + p[0] = b1 * r11 + g1 * r21; + p[1] = b1 * r12 + g1 * r22; + p[2] = b2 * r22; + return b2 * r21; +} + +double BidiagonalMatrix_applyRotatorFromLeft(BidiagonalMatrix_t *ptr, Rotator_t *r, int n, double bulge) +{ + double* p = ptr->pBlock + n * 2; + double b1 = p[0]; + double g1 = p[1]; + double b2 = p[2]; + double r11 = r->operator(r, 0, 0); + double r12 = r->operator(r, 0, 1); + double r21 = r->operator(r, 1, 0); + double r22 = r->operator(r, 1, 1); + + p[0] = r11 * b1 + r21 * bulge; + p[1] = r11 * g1 + r21 * b2; + p[2] = r12 * g1 + r22 * b2; + double newBulge; + if (n < N - 2) { + double g2 = p[3]; + newBulge = r21 * g2; + p[3] = r22 * g2; + } else { + newBulge = 0.0; + } + return newBulge; +} + +double BidiagonalMatrix_calculateShift(BidiagonalMatrix_t *m, int n) +{ + assert(M >= N); + assert(n >= 2); + double b1 = m->operator(m, n - 2, n - 2); + double b2 = m->operator(m, n - 1, n - 1); + double g1 = m->operator(m, n - 2, n - 1); + + // solves lambda^4 - d*lambda^2 + e = 0 + // where + // d = b1^2 + b2^2 + g1^2 + // e = b1^2 * b2^2 + // chooses lambda (rho) closest to b2 + double rho; + double d = b1 * b1 + b2 * b2 + g1 * g1; + double e = b1 * b1 * b2 * b2; + // lambda^2 = (d +- sqrt(d^2 - 4e)) / 2 + // so, f = d^2 - 4e must be positive + double f = d * d - 4 * e; + + if (f >= 0) { + f = sqrt(f); + // lambda = +-sqrt(d +- f) (d >= 0, f >= 0) + // if d > f, both d+f and d-f have real square roots + // otherwise considers only d+f + if (d > f) { + // lets l1 > l2 + double l1 = sqrt((d + f) * 0.5); + double l2 = sqrt((d - f) * 0.5); + // if b2 >= 0, chooses a positive shift + // otherwise chooses a negative shift + if (b2 >= 0) { + if (fabs(b2 - l1) < fabs(b2 - l2)) { + rho = l1; + } else { + rho = l2; + } + } else { + if (fabs(b2 + l1) < fabs(b2 + l2)) { + rho = -l1; + } else { + rho = -l2; + } + } + } else { + double l1 = sqrt((d + f) * 0.5); + if (fabs(b2 - l1) <= fabs(b2 + l1)) { + rho = l1; + } else { + rho = -l1; + } + } + } else { + // no solution. chooses b2 as the shift + rho = b2; + } + + return rho; +} + + + +void BidiagonalMatrix_doFrancis(BidiagonalMatrix_t *m, int n) +{ + assert(M >= N); + assert(n >= 2); + // calculates the shift + double rho = m->calculateShift(m, n); + + // applies the first right rotator + double b1 = m->operator(m, 0, 0); + double g1 = m->operator(m, 0, 1); + double mx = max(fabs(rho), max(fabs(b1), fabs(g1))); + rho /= mx; + b1 /= mx; + g1 /= mx; + //Rotator_t r0(b1 * b1 - rho * rho, b1 * g1); + + Rotator_t r0; + Rotator_init(&r0, b1 * b1 - rho * rho, b1 * g1); + + double bulge = m->applyFirstRotatorFromRight(m, &r0); + //v = r0.applyFromRightTo(&r0, v, 0); + // applies the first left rotator + + Rotator_t r1; + Rotator_init(&r1, m->operator(m, 0, 0), bulge); + //Rotator_t r1(m(0, 0), bulge); + bulge = m->applyRotatorFromLeft(m, &r1, 0, bulge); + //u = r1.applyFromRightTo(&r1, u, 0); // U1^T*U0^T = U0*U1 + + for (int i = 1; i + 1 < n; ++i) { + // calculates (i+1)-th right rotator + //Rotator rV(m(i - 1, i), bulge); + Rotator_t rV; + Rotator_init(&rV, m->operator(m, i - 1, i), bulge); + + bulge = m->applyRotatorFromRight(m, &rV, i, bulge); + //v = rV.applyFromRightTo(&rV, v, i); + // calculates (i+1)-th left rotator + //Rotator rU(m(i, i), bulge); + Rotator_t rU; + Rotator_init(&rU, m->operator(m, i, i), bulge); + + bulge = m->applyRotatorFromLeft(m, &rU, i, bulge); + //u = rU.applyFromRightTo(rU, u, i); // U1^T*U0^T = U0*U1 + } +} + +void BidiagonalMatrix_def(BidiagonalMatrix_t *p) +{ + p->applyFirstRotatorFromRight = BidiagonalMatrix_applyFirstRotatorFromRight; + p->applyRotatorFromLeft = BidiagonalMatrix_applyRotatorFromLeft; + p->applyRotatorFromRight = BidiagonalMatrix_applyRotatorFromRight; + p->bidiagonalize = BidiagonalMatrix_bidiagonalize; + p->calculateShift = BidiagonalMatrix_calculateShift; + p->doFrancis = BidiagonalMatrix_doFrancis; + p->operator = BidiagonalMatrix_operator; + p->releases = BidiagonalMatrix_release; + +} + +void BidiagonalMatrix_init(BidiagonalMatrix_t *p, Matrix_t *m) +{ + assert(M >= N); + int len; + len = 2 * N - 1; + + p->pBlock = (double *)malloc(sizeof(double)*len); + memset(p->pBlock, 0.0,sizeof(double)*len); + + for (int i = 0; i < N; ++i) { + p->pBlock[i * 2] = Matrix_operator(m, i, i);//m->operator(m, i, i); + if (i < N - 1) { + p->pBlock[i * 2 + 1] = Matrix_operator(m, i, i + 1);//m->operator(m, i, i + 1); + } + } +} + + +bool IsFullRank(const uint64_t matrix_[64*64]) +{ + double matrix__ [64*64]; + // Matrix<64, 64> matrix; + + + for (int i = 0; i < 64; ++i) { + for (int j = 0; j < 64; ++j) { + matrix__[64*i + j] = (double) matrix_[64*i + j]; + } + } + + DiagonalMatrix_t dm; + Matrix_t mt; + BidiagonalMatrix_t bt; + + DiagonalMatrix_init(&dm, matrix__); + //matrix.fill(matrix__); + + Matrix_init(&mt); + Matrix_def(&mt); + mt.filledwith(&mt, matrix__); + + BidiagonalMatrix_def(&bt); + DiagonalMatrix_t usv = Svd_decomposeUSV(&bt, &mt); + DiagonalMatrix_t singularValues = usv; + mt.release(&mt); + dm.release(&dm); + //DiagonalMatrix_release(&dm); + return Svd_isFullRank(&usv,64); + + + +} + + +uint64_t GetUint64_t(uint8_t *data, int pos) +{ + const uint8_t* ptr = data + pos * 8; + return ((uint64_t)ptr[0]) | \ + ((uint64_t)ptr[1]) << 8 | \ + ((uint64_t)ptr[2]) << 16 | \ + ((uint64_t)ptr[3]) << 24 | \ + ((uint64_t)ptr[4]) << 32 | \ + ((uint64_t)ptr[5]) << 40 | \ + ((uint64_t)ptr[6]) << 48 | \ + ((uint64_t)ptr[7]) << 56; +} + +void XoShiRo256PlusPlus_init(Obtc_t *Obtc, uint64_t *s, uint256 seed) { + for (int i = 0; i < 4; ++i) { + //p->s[i] = seed.GetUint64(i); + s[i] = GetUint64_t(Obtc->data_r,i); + } +} + +uint64_t RotateLeft64(const uint64_t x, int k) { + return (x << k) | (x >> (64 - k)); +} + + +uint64_t XoShiRo256PlusPlus_operator(uint64_t *s){ + const uint64_t result = RotateLeft64(s[0] + s[3], 23) + s[0]; + + const uint64_t t = s[1] << 17; + + s[2] ^= s[0]; + s[3] ^= s[1]; + s[1] ^= s[2]; + s[0] ^= s[3]; + + s[2] ^= t; + + s[3] = RotateLeft64(s[3], 45); + + return result; +} + +void GenerateHeavyHashMatrix_t(Obtc_t *Obtc, uint256 matrix_seed, uint64_t matrix[64*64]) +{ + XoShiRo256PlusPlus_init(Obtc, Obtc->ss, matrix_seed); + + do { + for (int i = 0; i < 64; ++i) { + for (int j = 0; j < 64; j += 16) { + uint64_t value = XoShiRo256PlusPlus_operator(Obtc->ss);//generator(); + for (int shift = 0; shift < 16; ++shift) { + matrix[64*i + j + shift] = (value >> (4 * shift)) & 0xF; + } + } + } + //} while (!Is4BitPrecision(matrix) || !IsFullRank(matrix)); + }while(!Is4BitPrecision(matrix)); +} + + + + +void serialize_heavyhash(Obtc_t *Obtc, uint64_t matrix[64*64], const char* in, char* out, int len) +{ + uint8_t temp[200]={ + 0x02,0xb9,0x7c,0x78,0x6f,0x82,0x43,0x83,0x5d,0x11,0x29,0xcf,0x82,0xaf,0xa5,0xbc,0xb1,0xfc,0xce,0x9c, + 0xe7,0x8b,0x52,0x72,0x48,0xb0,0x94,0x27,0xa8,0x74,0x2e,0xdb,0x89,0xca,0x4e,0x84,0x9b,0xce,0xcf,0x4a, + 0xd1,0x02,0x57,0x41,0x05,0x09,0x5f,0x8d,0xba,0x1d,0xe5,0xe4,0x45,0x16,0x68,0xe4,0xc1,0xa2,0x02,0x1d, + 0x56,0x3b,0xb1,0x42,0x8f,0x06,0xdd,0x1c,0x7a,0x2f,0x85,0x1a,0x34,0x85,0x54,0x90,0x64,0xa3,0x6a,0x46, + 0xb2,0x1a,0x60,0x1f,0x85,0xb4,0xb2,0x23,0xe6,0xc8,0x5d,0x8f,0x82,0xe9,0xda,0x89,0xec,0x70,0xf1,0xa4, + 0x25,0xb1,0x37,0x15,0x44,0xe3,0x67,0x87,0x5b,0x29,0x91,0x52,0x0f,0x96,0x07,0x05,0x40,0xf1,0x4a,0x0e, + 0x2e,0x65,0x1c,0x3c,0x43,0x28,0x5f,0xf0,0xf8,0xeb,0xf1,0x33,0x88,0x66,0x31,0x40,0x77,0x6b,0xf6,0x0c, + 0x78,0x9b,0xc2,0x9c,0x18,0x3a,0x98,0x1e,0xad,0x41,0x5b,0x10,0x4a,0xef,0x61,0xd6,0x29,0xdc,0xe2,0x46, + 0x7b,0x2f,0xaf,0xca,0x87,0x5e,0x2d,0x65,0x1b,0xa5,0xa4,0xa3,0xf5,0x98,0x69,0xa0,0x1e,0x5f,0x2e,0x72, + 0x0e,0xfb,0x44,0xd2,0x29,0xbf,0x88,0x55,0xb7,0x02,0x7e,0x3c,0x11,0x3c,0xff,0x0d,0xa1,0xf6,0xd8,0x3d + }; + for(int i = 0 ;i< 200 ;i++)Obtc->const_data[i] = temp[i]; + + CHeavyHash_init(Obtc, &Obtc->CHeavyHash_p, matrix); + CHeavyHash_Write(&Obtc->CHeavyHash_p, (const unsigned char*)in, len); + CHeavyHash_Finalize(Obtc, &Obtc->CHeavyHash_p, (unsigned char*)out); +} + + + +void opticalbtc_hash(const char* in, char* out, int len) +{ + uint8_t *ptr = (uint8_t*) in; + uint256 seed, hashprev; + uint64_t matrix[64*64]; + + Obtc_t Obtc; + + CSHA3_256_init(&Obtc, &Obtc.CSHA3_256_p); + memcpy(Obtc.data_r,ptr, 32); + GenerateHeavyHashMatrix_t(&Obtc, seed, matrix); + serialize_heavyhash(&Obtc, matrix, in, out, len); + +} + diff --git a/heavyHash/obtc.h b/heavyHash/obtc.h new file mode 100644 index 0000000..bdbaa2c --- /dev/null +++ b/heavyHash/obtc.h @@ -0,0 +1,52 @@ +#ifndef OBTC_H +#define OBTC_H + + +#include "uint256.h" +#include "xoshiro256pp.h" +#include "Svd.h" +#include "DiagonalMatrix.h" +#include "Matrix.h" +#include "Rotator.h" +#include "heavyhash.h" + + +typedef struct Obtc_opt Obtc_t; +struct Obtc_opt{ + uint8_t data_r[32]; + uint64_t ss[4]; + uint8_t const_data[200]; + CSHA3_256 CSHA3_256_p; + CHeavyHash CHeavyHash_p; + uint256 g_hash_first; + XoShiRo256PlusPlus_t *xo; + DiagonalMatrix_t g_DiagonalMatrix; + +}; + +//struct Obtc_opt; + + +bool Is4BitPrecision(const uint64_t matrix[64*64]); +bool IsFullRank(const uint64_t matrix_[64*64]); +void GenerateHeavyHashMatrix(uint256 matrix_seed, uint64_t matrix[64*64]); +void serialize_heavyhash(Obtc_t *Obtc, uint64_t matrix[64*64], const char* in, char* out, int len); +void opticalbtc_hash(const char* in, char* out, int len); + +extern void CSHA3_256_init(Obtc_t *Obtc, CSHA3_256 *p); +extern void CSHA3_256_CSHA3_256(Obtc_t *Obtc, CSHA3_256 *p); + +extern void CSHA3_256_Write(CSHA3_256 *p, const unsigned char* data, size_t len); + +extern void CSHA3_256_Finalize(CSHA3_256 *p, unsigned char hash[OUTPUT_SIZE]); +//extern void CSHA3_256_Reset(Obtc_t *Obtc, CSHA3_256 *p); + +extern void CHeavyHash_init(Obtc_t *Obtc, CHeavyHash *p, uint64_t matrix_[64*64]); +extern void CHeavyHash_Write(CHeavyHash *p, const unsigned char* data, size_t len); + +extern void CHeavyHash_Finalize(Obtc_t *Obtc, CHeavyHash *p, unsigned char hash[OUTPUT_SIZE]); + +extern int sha3_init(Obtc_t *Obtc,sha3_ctx_t *c, int mdlen); // mdlen = hash output in bytes + + +#endif // OBTC_H diff --git a/heavyHash/obtc.o b/heavyHash/obtc.o new file mode 100644 index 0000000000000000000000000000000000000000..bf11e3b97f2c91a6b4d4ca055e7da2e2fe38d5c0 GIT binary patch literal 25504 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 literal 0 HcmV?d00001 diff --git a/heavyHash/sha3.c b/heavyHash/sha3.c new file mode 100644 index 0000000..6bf9256 --- /dev/null +++ b/heavyHash/sha3.c @@ -0,0 +1,199 @@ +// sha3.c +// 19-Nov-11 Markku-Juhani O. Saarinen + +// Revised 07-Aug-15 to match with official release of FIPS PUB 202 "SHA3" +// Revised 03-Sep-15 for portability + OpenSSL - style API +#include +#include "sha3.h" +#include "obtc.h" + + + + +// update the state with given number of rounds + +void sha3_keccakf(uint64_t st[25]) +{ + // constants + const uint64_t keccakf_rndc[24] = { + 0x0000000000000001, 0x0000000000008082, 0x800000000000808a, + 0x8000000080008000, 0x000000000000808b, 0x0000000080000001, + 0x8000000080008081, 0x8000000000008009, 0x000000000000008a, + 0x0000000000000088, 0x0000000080008009, 0x000000008000000a, + 0x000000008000808b, 0x800000000000008b, 0x8000000000008089, + 0x8000000000008003, 0x8000000000008002, 0x8000000000000080, + 0x000000000000800a, 0x800000008000000a, 0x8000000080008081, + 0x8000000000008080, 0x0000000080000001, 0x8000000080008008 + }; + const int keccakf_rotc[24] = { + 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 2, 14, + 27, 41, 56, 8, 25, 43, 62, 18, 39, 61, 20, 44 + }; + const int keccakf_piln[24] = { + 10, 7, 11, 17, 18, 3, 5, 16, 8, 21, 24, 4, + 15, 23, 19, 13, 12, 2, 20, 14, 22, 9, 6, 1 + }; + + // variables + int i, j, r; + uint64_t t, bc[5]; + +#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__ + uint8_t *v; + + // endianess conversion. this is redundant on little-endian targets + for (i = 0; i < 25; i++) { + v = (uint8_t *) &st[i]; + st[i] = ((uint64_t) v[0]) | (((uint64_t) v[1]) << 8) | + (((uint64_t) v[2]) << 16) | (((uint64_t) v[3]) << 24) | + (((uint64_t) v[4]) << 32) | (((uint64_t) v[5]) << 40) | + (((uint64_t) v[6]) << 48) | (((uint64_t) v[7]) << 56); + } +#endif + + // actual iteration + for (r = 0; r < KECCAKF_ROUNDS; r++) { + + // Theta + for (i = 0; i < 5; i++) + bc[i] = st[i] ^ st[i + 5] ^ st[i + 10] ^ st[i + 15] ^ st[i + 20]; + + for (i = 0; i < 5; i++) { + t = bc[(i + 4) % 5] ^ ROTL64(bc[(i + 1) % 5], 1); + for (j = 0; j < 25; j += 5) + st[j + i] ^= t; + } + + // Rho Pi + t = st[1]; + for (i = 0; i < 24; i++) { + j = keccakf_piln[i]; + bc[0] = st[j]; + st[j] = ROTL64(t, keccakf_rotc[i]); + t = bc[0]; + } + + // Chi + for (j = 0; j < 25; j += 5) { + for (i = 0; i < 5; i++) + bc[i] = st[j + i]; + for (i = 0; i < 5; i++) + st[j + i] ^= (~bc[(i + 1) % 5]) & bc[(i + 2) % 5]; + } + + // Iota + st[0] ^= keccakf_rndc[r]; + } + +#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__ + // endianess conversion. this is redundant on little-endian targets + for (i = 0; i < 25; i++) { + v = (uint8_t *) &st[i]; + t = st[i]; + v[0] = t & 0xFF; + v[1] = (t >> 8) & 0xFF; + v[2] = (t >> 16) & 0xFF; + v[3] = (t >> 24) & 0xFF; + v[4] = (t >> 32) & 0xFF; + v[5] = (t >> 40) & 0xFF; + v[6] = (t >> 48) & 0xFF; + v[7] = (t >> 56) & 0xFF; + } +#endif +} + +// Initialize the context for SHA3 + +int sha3_init(Obtc_t *Obtc, sha3_ctx_t *c, int mdlen) +{ + int i; + + for (i = 0; i < 200; i++){ + c->st.b[i] = Obtc->const_data[199-i]; + } + + c->mdlen = mdlen; + c->rsiz = 200 - 2 * mdlen; + c->pt = 0; + + return 1; +} + +// update state with more data + +int sha3_update(sha3_ctx_t *c, const void *data, size_t len) +{ + size_t i; + int j; + + j = c->pt; + + for (i = 0; i < len; i++) { + c->st.b[j++] ^= ((const uint8_t *) data)[i]; + if (j >= c->rsiz) { + sha3_keccakf(c->st.q); + j = 0; + } + } + c->pt = j; + + return 1; +} + +// finalize and output a hash + +int sha3_final(void *md, sha3_ctx_t *c) +{ + int i; + + // c->st.b[c->pt] ^= 0x06; + c->st.b[c->pt] ^= 0x04; + c->st.b[c->rsiz - 1] ^= 0x80; + sha3_keccakf(c->st.q); + + for (i = 0; i < c->mdlen; i++) { + ((uint8_t *) md)[i] = c->st.b[i]; + } + + return 1; +} + +// compute a SHA-3 hash (md) of given byte length from "in" + +/*void *sha3(const void *in, size_t inlen, void *md, int mdlen) +{ + sha3_ctx_t sha3; + + sha3_init(&sha3, mdlen); + sha3_update(&sha3, in, inlen); + sha3_final(md, &sha3); + + return md; +}*/ + +// SHAKE128 and SHAKE256 extensible-output functionality + +void shake_xof(sha3_ctx_t *c) +{ + c->st.b[c->pt] ^= 0x1F; + c->st.b[c->rsiz - 1] ^= 0x80; + sha3_keccakf(c->st.q); + c->pt = 0; +} + +void shake_out(sha3_ctx_t *c, void *out, size_t len) +{ + size_t i; + int j; + + j = c->pt; + for (i = 0; i < len; i++) { + if (j >= c->rsiz) { + sha3_keccakf(c->st.q); + j = 0; + } + ((uint8_t *) out)[i] = c->st.b[j++]; + } + c->pt = j; +} + diff --git a/heavyHash/sha3.h b/heavyHash/sha3.h new file mode 100644 index 0000000..b4ff036 --- /dev/null +++ b/heavyHash/sha3.h @@ -0,0 +1,51 @@ +// sha3.h +// 19-Nov-11 Markku-Juhani O. Saarinen + +#ifndef SHA3_H +#define SHA3_H + + +#include +#include + + + + +#ifndef KECCAKF_ROUNDS +#define KECCAKF_ROUNDS 24 +#endif + +#ifndef ROTL64 +#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y)))) +#endif + +// state context +typedef struct { + union { // state: + uint8_t b[200]; // 8-bit bytes + uint64_t q[25]; // 64-bit words + } st; + int pt, rsiz, mdlen; // these don't overflow +} sha3_ctx_t; + +// Compression function. +void sha3_keccakf(uint64_t st[25]); + +// OpenSSL - like interfece + +int sha3_update(sha3_ctx_t *c, const void *data, size_t len); +int sha3_final(void *md, sha3_ctx_t *c); // digest goes to md + +// compute a sha3 hash (md) of given byte length from "in" +void *sha3(const void *in, size_t inlen, void *md, int mdlen); + +// SHAKE128 and SHAKE256 extensible-output functions +//#define shake128_init(c) sha3_init(c, 16) +//#define shake256_init(c) sha3_init(c, 32) +//#define shake_update sha3_update + +void shake_xof(sha3_ctx_t *c); +void shake_out(sha3_ctx_t *c, void *out, size_t len); + +#endif + diff --git a/heavyHash/sha3.o b/heavyHash/sha3.o new file mode 100644 index 0000000000000000000000000000000000000000..d84927a78d598a4ad22fa8c68107eaacba108b0b GIT binary patch literal 4632 zcmbuCVQf=X6vuDd4F(Q2V9E?6jED*WY728BAgPkdH9>+TRTCkjbe-T}Tei+jg;6Xe zdpt`PgJv-#@Iezl7{do7h@cw+orDi160;98Hc^uyd>C<&Mi=M*oO|C}`zRUeS=Rfz z=bU@*x#!&1-nT!v@p-q)B`k4?bz-7tX@wY^Il%$OfS4hsi;y&al?QH(V2m`*SN}ae z-XP7AM;F6I8o`{uPo|Q-@$vDmY0TMbR;Q(L?RWV}I@t<$S}dK6fjmr|peamyLDQMy zpbDmgpa+?{LGzj311)0e0WD`b3VMpE7vyF-2BKZ0lP5s)m_7zAVfqxbis>^@8PiG7 z!%U|@OPS7q)-jy}&1UKYJ21!ncS7VGF5ene59GI zhF!Wc(yX+NiM~>qDlc>xkfxCS3wb`%@586!K76Vs^)ZfK3Lwe^2k%Opr!AFK9C-p; z&fDM5_Wn|`jg7{@o!_qgX$sFJl4q8NJHeBeCeG8S z>aOF??bErj>SqSZ?2zn&8+JluuX!+;!88WXY4T^05OE6d1(Kv>-_yrF0+_NDj?(;s zQepJV?=MROnQ48?`vJ6GgnacG5H!oYbNxqwA}Q32*dK z5+*54s@6T33q2sK{{3OOlX=1Dvxd3v_l#{^h%=Ux#*~8G;l!^*?h21Z#gT8g2I?`U zXP6#;l-4|WiGBg_$XaK_s7$aC4-omF6hHknKHekEV6H)~RKFgv(qXE~ci-|ajInQ6 z8XZ|9G?WgGk^bf*XVPev2FIis8kW5kr#HF-z^n;PZ+E#n5gcID*8m}_yCCH41IrXQ%fgq`J`T68lgcr4x8*~1V?2$m?Qt2 zFPp*9)Ml3v8kOdY!!nYoI9)pnm_AF&Jdba-u=%ElfJe`@utr|N#+GRI6z&opgq?Ay0O5BN&65}#= zBmIHyS_%O^6hcbk(Xl#-VXQhaCVtnLi8xgu7E;C|IF#5zigu=JKx=lps0?ayO8uJP z*#1mm^p%J{2alW`dCrbJXGOk%qsU1+a`;R{t~)AndyI-ae~cA5tu|5X9y^iuQD;fp zRBPX}aFji&8bDq(vEP_Fr@`Mf|$-8lG#9`IO1^o#TH&vhRY)l8V zewxz955tM1TQvguI3cbf++w_HNeP`1SFK04Zr!Rz#HVY}!^9sTkG{Luj}BRzsq0e_0@X)E0!oj%?h8t&R6GqS_nZ`4ieYfTZF5# z(lxJqYFQ5^rz;=*lkA}T#{#wxps#w>Idy<0p22`eHVL5VLE@|>L)C)Wl#x|Gso)hUlbLH?E>*9tnH*8ixN;2J@< zR_pibP`NhHZP5DFI#jL+bT4WBC9UULKquOFhF5wc+|)NkBav`Zqo}WMkA)*m^^u)T z^^M_OyOniU^RAepj@E{7EULJ1S96#hnxgfcEsdlEwRFU2av|ttf`qR5`Pts8_d}Oz zvW?*vkz|wJ59#S5ZR!8GhyJAAkJEoD4Td=NHLO*7vRM+)Ksx%j>ag9Rx9Sjg=&d@O zaOkZ%^f~la9fY_2tv#{u4z#g0)$X*YExJ4GjYT_S!i#)|g?C4LyYRNPs7|D1&z@*A zY|SmPsCUDr&~h#s9B5c{XMJN^cu!O>`@fqS%s|hi^P~r$BiW+!t$NDWVruF2lAgi< z{_|z?4Atw=N_zF9b#z$;y}FUm^Fey&6aKzqUGgO%-+Wny4$b*r$NMps=FC4c=!z41 z{XXjCNlhLT(swwGr{_6ew$tH<)Tze)wBong=U}neb^?5;$LH&aoxZPVoiqMkJ$}$J zft7zty#-LLe%T`Rqp{X_tA6w%@60{T-AZrJkg#g(PiOqpcg9Z6t#n`@aXp|MOeJxy TPr733kI(?fYpSt7o$LPt)Z$Av literal 0 HcmV?d00001 diff --git a/heavyHash/singular.h b/heavyHash/singular.h new file mode 100644 index 0000000..cd3540f --- /dev/null +++ b/heavyHash/singular.h @@ -0,0 +1,42 @@ +#ifndef _SINGULAR_SINGULAR_H +#define _SINGULAR_SINGULAR_H + +/** The version of the singular library. */ +#define SINGULAR_VERSION "@PROJECT_VERSION@" + +/** + * Whether rvalue references are supported. + * + * Visual Studio 2010 and lower do not have rvalue references so far. + */ +#if defined(_MSC_VER) && _MSC_VER < 1700 +#define SINGULAR_RVALUE_REFERENCE_SUPPORTED 0 +#else +#define SINGULAR_RVALUE_REFERENCE_SUPPORTED 1 +#endif + +/** + * Whether function deletions are supported. + * + * Visual Studio 2012 and lower do not like "delete" stuff so far. + */ +#if defined(_MSC_VER) && _MSC_VER < 1800 +#define SINGULAR_FUNCTION_DELETION_SUPPORTED 0 +#else +#define SINGULAR_FUNCTION_DELETION_SUPPORTED 1 +#endif + +/** + * Whether template friend operator overalodings are supported. + * + * Visual Studio 2012 and lower do not like overloading a template firend + * operators. + * Neither does GCC. + */ +#if (defined(_MSC_VER) && _MSC_VER < 1800) || (defined(__GNUC__) && !defined(__clang__)) +#define SINGULAR_TEMPLATE_FRIEND_OPERATOR_OVERLOADING_SUPPORTED 0 +#else +#define SINGULAR_TEMPLATE_FRIEND_OPERATOR_OVERLOADING_SUPPORTED 1 +#endif + +#endif diff --git a/heavyHash/test.c b/heavyHash/test.c new file mode 100644 index 0000000..2d28982 --- /dev/null +++ b/heavyHash/test.c @@ -0,0 +1,183 @@ +#include +#include +#include + +#include "obtc.h" +#include "singular.h" +#include + + +//uint8_t const_data[200]; + +static const int hex2bin_tbl[256] = { + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, + -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +}; + +bool hex2bin(unsigned char *p, const char *hexstr, size_t len) +{ + int nibble1, nibble2; + unsigned char idx; + bool ret = false; + + while (*hexstr && len) { + if ((!hexstr[1])) { + printf("hex2bin str truncated"); + return ret; + } + + idx = *hexstr++; + nibble1 = hex2bin_tbl[idx]; + idx = *hexstr++; + nibble2 = hex2bin_tbl[idx]; + + if (((nibble1 < 0) || (nibble2 < 0))) { + printf("hex2bin scan failed"); + return ret; + } + + *p++ = (((unsigned char)nibble1) << 4) | ((unsigned char)nibble2); + --len; + } + + if ((len == 0 && *hexstr == 0)) + ret = true; + return ret; +} + + +int main(int argc, char **argv) +{ + uint8_t genesis_block[80]; + uint8_t hash[32]; + + uint8_t last_prehash[32]; + uint8_t last_prehash2[32]; + uint8_t prehash_tab[32]; + uint8_t nonce_tab[8]; + char *prehash_str = "d76ffb1d8e31ec04579b0452b52bde7dbd088e912ab1b11ba924ff309ab44a43";//argv[1]; + char *nonce_str = "80aa59a7901f2502";//argv[2]; + //char *last_prehash_str = argv[3]; + //char *last_prehash_str2 = argv[4]; + + hex2bin(prehash_tab, prehash_str, strlen(prehash_str)/2); + hex2bin(nonce_tab, nonce_str, strlen(nonce_str)/2); + //hex2bin(last_prehash, last_prehash_str, strlen(last_prehash_str)/2); + //hex2bin(last_prehash2, last_prehash_str2, strlen(last_prehash_str2)/2); + /*for (uint8_t i = 0; i<32;i++){ + printf("0x%x, ",prehash_tab[i]); + } + printf("\n"); + + for (uint8_t i = 0; i<8;i++){ + printf("0x%x, ",nonce_tab[i]); + } + printf("\n");*/ + + //uint8_t prehash[32] = {0x81,0x55,0x3a,0x69,0x5a,0x05,0x88,0x99,0x8c,0x41,0x37,0x92,0xe7,0x4c,0xe8,0xb8,0xf8,0xa0,0x96,0xd6,0x4b,0x3e,0xe4,0x73,0x87,0x37,0x24,0x34,0x48,0x5c,0x0b,0x6f}; + //uint8_t utime[8] = {0x00,0x00,0x01,0x84,0x8c,0xa8,0x7c,0x49}; + uint8_t pad[32] = {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}; + //uint8_t nonce[8] = {0x2f,0x84,0x00,0x00,0x0e,0xba,0x16,0x7c}; + +#if 0 + //uint8_t prehash[32] = {0xa4,0x8f,0xae,0x69,0xeb,0x28,0xc7,0xe0,0x14,0x11,0x4f,0x01,0xae,0x60,0xc8,0xc3,0x82,0x73,0xc4,0x60,0x66,0xcf,0x95,0xd6,0x77,0x1a,0x55,0xd6,0x16,0xd7,0xa1,0x9a};//大端 + //uint8_t utime[8] = {0x00,0x00,0x01,0x87,0x22,0x1e,0xad,0x44}; + //uint8_t nonce[8] = {0x8e,0xd4,0x00,0x10,0x6b,0xe7,0xe4,0x00}; + //uint8_t nonce[8] = {0x8e,0xd4,0x00,0x12,0x27,0xc6,0x90,0xa0}; + //uint8_t nonce[8] = {0x8e,0xd4,0x00,0x32,0x0b,0x6b,0xd6,0xd1}; + + + //3f 9a aa c6 32 af 1a 4e 0e 1f ea 8a f8 e3 d5 32 b7 5a a4 71 b2 e4 ef fe a5 bd cc fa 3b dd b6 61 + uint8_t prehash[32] = {0x3f,0x9a,0xaa,0xc6,0x32,0xaf,0x1a,0x4e,0x0e,0x1f,0xea,0x8a,0xf8,0xe3,0xd5,0x32,0xb7,0x5a,0xa4,0x71,0xb2,0xe4,0xef,0xfe,0xa5,0xbd,0xcc,0xfa,0x3b,0xdd,0xb6,0x61};//大端 + uint8_t utime[8] = {0x00,0x00,0x01,0x87,0x21,0xeb,0x73,0x79}; + uint8_t nonce[8] = {0xa3,0xdd,0x02,0x10,0x1a,0x87,0xb4,0x70}; + + + + +#else + + + /*443e01000000ffff00000000 + e0af2a3ba173157d3f70c94aad742fdf16d9930fdfc9d6301e869bcef04ced6c + e0af2a3ba173157d3f70c94aad742fdf16d9930fdfc9d6301e869bcef04ced6c + dbee84288701000000000000901f25020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + + [2023-03-28 22:00:46.549] 00 cc 01 11 70 83 85 16 90 1f 25 02 + + kas_pow_hash: in:e0af2a3ba173157d3f70c94aad742fdf16d9930fdfc9d6301e869bcef04ced6cdbee842887010000000000000000000000000000000000000000000000000000000000000000000070838516901f2502 + kas_pow_hash: out:dae78f5008d3b66f + 01a740ce33c812ba + 772b3f5763da7bc6 + da24cb6c00000000*/ + + uint8_t prehash[32] = {0xe0,0xaf,0x2a,0x3b,0xa1,0x73,0x15,0x7d,0x3f,0x70,0xc9,0x4a,0xad,0x74,0x2f,0xdf,0x16,0xd9,0x93,0x0f,0xdf,0xc9,0xd6,0x30,0x1e,0x86,0x9b,0xce,0xf0,0x4c,0xed,0x6c}; + //uint8_t utime[8] = {0x00,0x00,0x01,0x87,0x28,0x84,0xee,0xdb}; + uint8_t nonce[8] = {0x02,0x25,0x1f,0x90,0x16,0x85,0x83,0x70}; + +#endif + + /*for (int i = 0; i < 32; ++i) genesis_block[i] = prehash[i]; + for (int i = 0; i < 8; ++i) genesis_block[i+32] = utime[7-i]; + for (int i = 0; i < 32; ++i) genesis_block[i+40] = pad[31-i]; + for (int i = 0; i < 8; ++i) genesis_block[i+72] = nonce[7-i];*/ + //uint8_t utime[8] = {0x00,0x00,0x01,0x87,0x21,0xeb,0x73,0x79}; + //dbee8428870100000 + uint8_t utime[8] = {0x00,0x00,0x01,0x87,0x28,0x84,0xee,0xdb}; + + for (int i = 0; i < 32; ++i) genesis_block[i] = prehash_tab[i]; + for (int i = 0; i < 8; ++i) genesis_block[i+32] = utime[7-i]; + for (int i = 0; i < 32; ++i) genesis_block[i+40] = pad[31-i]; + for (int i = 0; i < 8; ++i) genesis_block[i+72] = nonce_tab[i]; + + clock_t start, finish; + double Total_time; + uint32_t cnt = 0;; + //while(1) + { + start = clock(); + opticalbtc_hash((const char*)&genesis_block, (char*)&hash, sizeof(genesis_block)); + finish = clock(); + Total_time = (double)(finish-start) / CLOCKS_PER_SEC; + printf( "\n cnt = %d, opticalbtc_hash run times %f seconds\n", cnt++, Total_time); + + for (int i=31; i>-1; i--) { + printf("%02hhx", hash[i]); + } + printf("\n"); + } + + + //if (hash[31] != 0 || hash[30] != 0){ + // for (int i = 0; i < 32; ++i) genesis_block[i] = last_prehash[i]; + // opticalbtc_hash((const char*)&genesis_block, (char*)&hash, sizeof(genesis_block)); + //} + + //if (hash[31] != 0 || hash[30] != 0){ + // for (int i = 0; i < 32; ++i) genesis_block[i] = last_prehash2[i]; + // opticalbtc_hash((const char*)&genesis_block, (char*)&hash, sizeof(genesis_block)); + //} + + if (hash[31] != 0 && hash[30] != 0){ + printf("reject\n"); + } + + return 0; +} + + +//g++ -std=c++11 *.cpp diff --git a/heavyHash/uint256.h b/heavyHash/uint256.h new file mode 100644 index 0000000..72b36d1 --- /dev/null +++ b/heavyHash/uint256.h @@ -0,0 +1,44 @@ +// Copyright (c) 2009-2010 Satoshi Nakamoto +// Copyright (c) 2009-2016 The Bitcoin Core developers +// Distributed under the MIT software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#ifndef BITCOIN_UINT256_H +#define BITCOIN_UINT256_H + +#include +//#include +//#include +#include +#include +//#include +#include + + + +/** 256-bit opaque blob. + * @note This type is called uint256 for historical reasons only. It is an + * opaque blob of 256 bits and has no integer operations. Use arith_uint256 if + * those are required. + */ +#define UPPER_P(x) x->elements[0] +#define LOWER_P(x) x->elements[1] +#define UPPER(x) x.elements[0] +#define LOWER(x) x.elements[1] +#define WIDTH 32 + +typedef struct class_base_blob base_blob_t; +struct class_base_blob{ + uint8_t data[WIDTH]; +}; + + +typedef struct uint128_t { uint64_t elements[2]; } uint128_t; +typedef struct uint256_t { + uint128_t elements[2]; + base_blob_t bb; +} uint256; + + + +#endif // BITCOIN_UINT256_H diff --git a/heavyHash/xoshiro256pp.h b/heavyHash/xoshiro256pp.h new file mode 100644 index 0000000..4bf39fa --- /dev/null +++ b/heavyHash/xoshiro256pp.h @@ -0,0 +1,15 @@ +#ifndef OPOW_CRYPTO_XOSHIRO256PP_H +#define OPOW_CRYPTO_XOSHIRO256PP_H + +#include +#include "uint256.h" + + +typedef struct class_XoShiRo256PlusPlus XoShiRo256PlusPlus_t; +struct class_XoShiRo256PlusPlus{ + uint64_t s[4]; +}; + + + +#endif //OPOW_CRYPTO_XOSHIRO256PP_H diff --git a/randomx/a.exe b/randomx/a.exe new file mode 100644 index 0000000000000000000000000000000000000000..6241a1e5c2295185c84a03aa2a6f05f0ffe5ec46 GIT binary patch literal 631893 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

v3akGQ_obX@(@Gx@YHpWF-0pEi-*Y2V+c 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