sek1ro/libbasen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(sha256, baseN): without overloading, just on vector

Browse Source
This commit is contained in:
SEK1RO
2024-09-11 16:32:33 +03:00
parent 7ddb0b5397
commit f2d9318a45
6 changed files with 460 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
.gitignore vendored Normal file
View File

@ -0,0 +1,47 @@
# ---> C++
# Prerequisites
*.d
# Compiled Object files
*.slo
*.lo
*.o
*.obj
# Precompiled Headers
*.gch
*.pch
# Compiled Dynamic libraries
*.so
*.dylib
*.dll
# Fortran module files
*.mod
*.smod
# Compiled Static libraries
*.lai
*.la
*.a
*.lib
# Executables
*.exe
*.out
*.app
# Bazel
bazel-*
*.bazel*
WORKSPACE.bazel
BUILD.bazel
# Dirs
bin
obj
lib
# IDE
.vscode

104
Makefile Normal file
View File

@ -0,0 +1,104 @@
-l =
SHARED ?= false
DEBUG ?= false
.PHONY: build i install uni uninstall\
tools library tests clean
LIB = base
OBJS =\
baseN\
hash/sha256\
TOOLS =\
TESTS =\
ifeq (${origin CC}, default)
CC = g++
endif
CFLAGS = -Wall -Wextra -Werror -Wno-unused-result -fPIC
ifneq (${DEBUG}, false)
CFLAGS += -fsanitize=address,undefined -g -Og
-g = -g
else
CFLAGS += -O3
endif
SRCDIR = src
INCDIR = include
OBJDIR = obj
BINDIR = bin
LIBDIR = lib
TESTDIR = test
USRDIR = /usr
DIRS =\
${BINDIR}\
${BINDIR}/hash\
${OBJDIR}\
${OBJDIR}/hash\
${LIBDIR}\
build: library tools
i: install
install: build ${patsubst %, ${USRDIR}/${BINDIR}/btc-%${-g}, ${TOOLS}}\
${USRDIR}/${LIBDIR}/lib${LIB}${-g}.a ${USRDIR}/${LIBDIR}/lib${LIB}${-g}.so
uni: uninstall
uninstall:
rm -f ${USRDIR}/${LIBDIR}/lib${LIB}${-g}.a
rm -f ${USRDIR}/${LIBDIR}/lib${LIB}${-g}.so
rm -f ${patsubst %, ${USRDIR}/${BINDIR}/btc-%${-g}, ${TOOLS}}
clean:
rm -rf ${OBJDIR} ${LIBDIR} ${BINDIR}
ifneq (${OBJS},)
library: ${DIRS} ${LIBDIR}/lib${LIB}${-g}.a ${BINDIR}/lib${LIB}${-g}.so
${OBJDIR}/%${-g}.o: ${SRCDIR}/%.cpp ${INCDIR}/${LIB}/%.hpp
${CC} -o $@ -c $< -I${INCDIR} ${-l} ${CFLAGS}
${BINDIR}/lib${LIB}${-g}.so: ${patsubst %, ${OBJDIR}/%${-g}.o, ${OBJS}}
${CC} -shared -o $@ $^
${LIBDIR}/lib${LIB}${-g}.a: ${patsubst %, ${OBJDIR}/%${-g}.o, ${OBJS}}
ar rcs $@ $^
${USRDIR}/${LIBDIR}/lib${LIB}${-g}.so: ${BINDIR}/lib${LIB}${-g}.so
cp $< $@
${USRDIR}/${LIBDIR}/lib${LIB}${-g}.a: ${LIBDIR}/lib${LIB}${-g}.a
cp $< $@
endif
ifneq (${TOOLS},)
tools: library ${DIRS} ${patsubst %, ${BINDIR}/%${-g}, ${TOOLS}}
${BINDIR}/%${-g}: ${SRCDIR}/%.cpp ${patsubst %, ${OBJDIR}/%${-g}.o, ${OBJS}}
ifneq (${SHARED}, false)
${CC} -o $@ $< -I${INCDIR} -L${BINDIR} ${-l} -l${LIB}${-g} ${CFLAGS}
else
${CC} -o $@ $< -I${INCDIR} -L${LIBDIR} ${-l} -l${LIB}${-g} ${CFLAGS}
endif
${USRDIR}/${BINDIR}/btc-%${-g}: ${BINDIR}/%${-g}
cp $< $@
endif
ifneq (${TESTS},)
tests: library ${DIRS} ${patsubst %, ${BINDIR}/%${-g}, ${TESTS}}
${patsubst %, ./${BINDIR}/%${-g};, ${TESTS}}
${BINDIR}/%${-g}: ${TESTDIR}/%.cpp ${patsubst %, ${OBJDIR}/%${-g}.o, ${OBJS}}
${CC} -o $@ $< -I${INCDIR} -L${LIBDIR} ${-l} -l${LIB}${-g} -lgtest ${CFLAGS}
endif
${DIRS}:
mkdir $@

12
include/base/baseN.hpp Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include <cstdint>
#include <string>
#include <vector>
namespace baseN
{
bool isValid(const std::string &str, const int8_t *map) noexcept;
std::string encode(std::vector<uint8_t> data, uint8_t base, uint64_t enc_size, const char *digits) noexcept;
std::vector<uint8_t> decode(const std::string &str, uint8_t base, uint64_t dec_size, const char *digits, const int8_t *map);
}

10
include/base/hash/sha256.hpp Normal file
View File

@ -0,0 +1,10 @@
#pragma once
#include <cstdint>
#include <vector>
#define SHA256_DIGEST_LENGTH 32
namespace hash {
std::vector<uint8_t> sha256(const std::vector<uint8_t> &data);
}

112
src/baseN.cpp Normal file
View File

@ -0,0 +1,112 @@
#include <stdexcept>
#include <base/baseN.hpp>
namespace baseN
{
bool isValid(const std::string &str, const int8_t *map) noexcept
{
for (int64_t i = str.size() - 1; i >= 0; i--)
{
if (map[(int8_t)str[i]] == -1)
{
return false;
}
}
return true;
}
std::string encode(std::vector<uint8_t> data, uint8_t base, uint64_t enc_size, const char *digits) noexcept
{
if (data.size() == 0)
{
return "";
}
std::string str(enc_size, ' ');
int64_t
zero_count = 0,
idx_div = 0,
idx_quo = 0,
idx_quo_last = data.size(),
idx_str = str.size() - 1;
uint16_t div = data[idx_div++];
while (data[zero_count] == 0)
{
zero_count++;
}
while (idx_quo_last > 1 || data[0] > base)
{
if (div < base)
{
div <<= 8;
div += data[idx_div++];
}
data[idx_quo++] = div / base;
div %= base;
while (idx_div < idx_quo_last)
{
div <<= 8;
div += data[idx_div++];
data[idx_quo++] = div / base;
div %= base;
}
idx_quo_last = idx_quo;
idx_quo = 0;
idx_div = 0;
str[idx_str--] = digits[div];
div = data[idx_div++];
}
str[idx_str--] = digits[div];
while (zero_count > 0 && idx_str > 0)
{
str[idx_str--] = '1';
zero_count--;
}
str.erase(0, idx_str + 1);
return str;
}
std::vector<uint8_t> decode(const std::string &str, uint8_t base, uint64_t dec_size, const char *digits, const int8_t *map)
{
if (str.size() == 0)
{
return std::vector<uint8_t>();
}
if (!baseN::isValid(str, map))
{
throw std::logic_error("baseN::decode: out of digits map");
}
std::vector<uint8_t> data(dec_size);
uint64_t idx_str = 0;
int64_t
zero_count = 0,
idx_quo = data.size() - 1,
idx_quo_last = data.size() - 2;
uint16_t div;
while (str[zero_count] == digits[0])
{
zero_count++;
}
data[idx_quo] = map[(int8_t)str[idx_str++]];
while (idx_str < str.size())
{
div = map[(int8_t)str[idx_str++]];
while (idx_quo > idx_quo_last && idx_quo > 0)
{
div += data[idx_quo] * base;
data[idx_quo--] = div;
div >>= 8;
}
data[idx_quo--] = div;
idx_quo_last = idx_quo;
idx_quo = data.size() - 1;
}
idx_quo = 0;
while (data[idx_quo] == 0)
{
idx_quo++;
}
data.erase(data.begin(), data.begin() + idx_quo - zero_count);
return data;
}
}

175
src/hash/sha256.cpp Normal file
View File

@ -0,0 +1,175 @@
/*********************************************************************
* Filename: sha256.c
* Author: Brad Conte (brad AT bradconte.com)
* Copyright:
* Disclaimer: This code is presented "as is" without any guarantees.
* Details: Implementation of the SHA-256 hashing algorithm.
SHA-256 is one of the three algorithms in the SHA2
specification. The others, SHA-384 and SHA-512, are not
offered in this implementation.
Algorithm specification can be found here:
* http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf
This implementation uses little endian byte order.
*********************************************************************/
#include <memory.h>
#include <stdlib.h>
#include <base/hash/sha256.hpp>
#define ROTLEFT(a,b) (((a) << (b)) | ((a) >> (32-(b))))
#define ROTRIGHT(a,b) (((a) >> (b)) | ((a) << (32-(b))))
#define CH(x,y,z) (((x) & (y)) ^ (~(x) & (z)))
#define MAJ(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
#define EP0(x) (ROTRIGHT(x,2) ^ ROTRIGHT(x,13) ^ ROTRIGHT(x,22))
#define EP1(x) (ROTRIGHT(x,6) ^ ROTRIGHT(x,11) ^ ROTRIGHT(x,25))
#define SIG0(x) (ROTRIGHT(x,7) ^ ROTRIGHT(x,18) ^ ((x) >> 3))
#define SIG1(x) (ROTRIGHT(x,17) ^ ROTRIGHT(x,19) ^ ((x) >> 10))
struct SHA256_CTX{
uint8_t data[64];
uint32_t datalen;
unsigned long long bitlen;
uint32_t state[8];
};
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 sha256_transform(SHA256_CTX *ctx, const uint8_t *data)
{
uint32_t a, b, c, d, e, f, g, h, i, j, t1, t2, m[64];
for (i = 0, j = 0; i < 16; ++i, j += 4)
m[i] = (data[j] << 24) | (data[j + 1] << 16) | (data[j + 2] << 8) | (data[j + 3]);
for ( ; i < 64; ++i)
m[i] = SIG1(m[i - 2]) + m[i - 7] + SIG0(m[i - 15]) + m[i - 16];
a = ctx->state[0];
b = ctx->state[1];
c = ctx->state[2];
d = ctx->state[3];
e = ctx->state[4];
f = ctx->state[5];
g = ctx->state[6];
h = ctx->state[7];
for (i = 0; i < 64; ++i) {
t1 = h + EP1(e) + CH(e,f,g) + k[i] + m[i];
t2 = EP0(a) + MAJ(a,b,c);
h = g;
g = f;
f = e;
e = d + t1;
d = c;
c = b;
b = a;
a = t1 + t2;
}
ctx->state[0] += a;
ctx->state[1] += b;
ctx->state[2] += c;
ctx->state[3] += d;
ctx->state[4] += e;
ctx->state[5] += f;
ctx->state[6] += g;
ctx->state[7] += h;
}
static void sha256_init(SHA256_CTX *ctx)
{
ctx->datalen = 0;
ctx->bitlen = 0;
ctx->state[0] = 0x6a09e667;
ctx->state[1] = 0xbb67ae85;
ctx->state[2] = 0x3c6ef372;
ctx->state[3] = 0xa54ff53a;
ctx->state[4] = 0x510e527f;
ctx->state[5] = 0x9b05688c;
ctx->state[6] = 0x1f83d9ab;
ctx->state[7] = 0x5be0cd19;
}
static void sha256_update(SHA256_CTX *ctx, const uint8_t *data, size_t len)
{
uint32_t i;
for (i = 0; i < len; ++i) {
ctx->data[ctx->datalen] = data[i];
ctx->datalen++;
if (ctx->datalen == 64) {
sha256_transform(ctx, ctx->data);
ctx->bitlen += 512;
ctx->datalen = 0;
}
}
}
static void sha256_final(SHA256_CTX *ctx, uint8_t *hash)
{
uint32_t i;
i = ctx->datalen;
// Pad whatever data is left in the buffer.
if (ctx->datalen < 56) {
ctx->data[i++] = 0x80;
while (i < 56)
ctx->data[i++] = 0x00;
}
else {
ctx->data[i++] = 0x80;
while (i < 64)
ctx->data[i++] = 0x00;
sha256_transform(ctx, ctx->data);
memset(ctx->data, 0, 56);
}
// Append to the padding the total message's length in bits and transform.
ctx->bitlen += ctx->datalen * 8;
ctx->data[63] = ctx->bitlen;
ctx->data[62] = ctx->bitlen >> 8;
ctx->data[61] = ctx->bitlen >> 16;
ctx->data[60] = ctx->bitlen >> 24;
ctx->data[59] = ctx->bitlen >> 32;
ctx->data[58] = ctx->bitlen >> 40;
ctx->data[57] = ctx->bitlen >> 48;
ctx->data[56] = ctx->bitlen >> 56;
sha256_transform(ctx, ctx->data);
// Since this implementation uses little endian byte ordering and SHA uses big endian,
// reverse all the bytes when copying the final state to the output hash.
for (i = 0; i < 4; ++i) {
hash[i] = (ctx->state[0] >> (24 - i * 8)) & 0x000000ff;
hash[i + 4] = (ctx->state[1] >> (24 - i * 8)) & 0x000000ff;
hash[i + 8] = (ctx->state[2] >> (24 - i * 8)) & 0x000000ff;
hash[i + 12] = (ctx->state[3] >> (24 - i * 8)) & 0x000000ff;
hash[i + 16] = (ctx->state[4] >> (24 - i * 8)) & 0x000000ff;
hash[i + 20] = (ctx->state[5] >> (24 - i * 8)) & 0x000000ff;
hash[i + 24] = (ctx->state[6] >> (24 - i * 8)) & 0x000000ff;
hash[i + 28] = (ctx->state[7] >> (24 - i * 8)) & 0x000000ff;
}
}
namespace btc::hash
{
std::vector<uint8_t> sha256(const std::vector<uint8_t> &data)
{
std::vector<uint8_t> hash(SHA256_DIGEST_LENGTH);
SHA256_CTX ctx;
sha256_init(&ctx);
sha256_update(&ctx, data.data(), data.size());
sha256_final(&ctx, hash.data());
return hash;
}
}