mirror of
https://github.com/bsnes-emu/bsnes.git
synced 2025-09-09 08:10:50 +02:00
Update to v101r19 release.
byuu says:
Changelog:
- added \~130 new PAL games to icarus (courtesy of Smarthuman
and aquaman)
- added all three Korean-localized games to icarus
- sfc: removed SuperDisc emulation (it was going nowhere)
- sfc: fixed MSU1 regression where the play/repeat flags were not
being cleared on track select
- nall: cryptography support added; will be used to sign future
databases (validation will always be optional)
- minor shims to fix compilation issues due to nall changes
The real magic is that we now have 25-30% of the PAL SNES library in
icarus!
Signing will be tricky. Obviously if I put the public key inside the
higan archive, then all anyone has to do is change that public key for
their own releases. And if you download from my site (which is now over
HTTPS), then you don't need the signing to verify integrity. I may just
put the public key on my site on my site and leave it at that, we'll
see.
This commit is contained in:
Tim Allen
@@ -1,45 +1,30 @@
|
||||
#pragma once
|
||||
|
||||
#include <nall/range.hpp>
|
||||
#include <nall/string.hpp>
|
||||
#include <nall/hash/hash.hpp>
|
||||
|
||||
namespace nall { namespace Hash {
|
||||
|
||||
struct CRC16 {
|
||||
CRC16() { reset(); }
|
||||
CRC16(const void* values, uint size) : CRC16() { data(values, size); }
|
||||
CRC16(const vector<uint8_t>& values) : CRC16() { data(values); }
|
||||
CRC16(const string& values) : CRC16() { data(values); }
|
||||
struct CRC16 : Hash {
|
||||
nallHash(CRC16)
|
||||
|
||||
auto reset() -> void {
|
||||
auto reset() -> void override {
|
||||
checksum = ~0;
|
||||
}
|
||||
|
||||
auto data(uint8_t value) -> void {
|
||||
auto input(uint8_t value) -> void override {
|
||||
checksum = (checksum >> 8) ^ table(checksum ^ value);
|
||||
}
|
||||
|
||||
auto data(const void* values, uint size) -> void {
|
||||
auto p = (const uint8_t*)values;
|
||||
while(size--) data(*p++);
|
||||
}
|
||||
|
||||
auto data(const vector<uint8_t>& values) -> void {
|
||||
for(auto value : values) data(value);
|
||||
}
|
||||
|
||||
auto data(const string& values) -> void {
|
||||
for(auto value : values) data(value);
|
||||
auto output() const -> vector<uint8_t> override {
|
||||
vector<uint8_t> result;
|
||||
for(auto n : rrange(2)) result.append(~checksum >> n * 8);
|
||||
return result;
|
||||
}
|
||||
|
||||
auto value() const -> uint16_t {
|
||||
return ~checksum;
|
||||
}
|
||||
|
||||
inline auto digest() const -> string {
|
||||
return hex(value(), 4L);
|
||||
}
|
||||
|
||||
private:
|
||||
static auto table(uint8_t index) -> uint16_t {
|
||||
static uint16_t table[256] = {0};
|
||||
@@ -59,7 +44,7 @@ private:
|
||||
return table[index];
|
||||
}
|
||||
|
||||
uint16_t checksum;
|
||||
uint16_t checksum = 0;
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
@@ -1,45 +1,30 @@
|
||||
#pragma once
|
||||
|
||||
#include <nall/range.hpp>
|
||||
#include <nall/string.hpp>
|
||||
#include <nall/hash/hash.hpp>
|
||||
|
||||
namespace nall { namespace Hash {
|
||||
|
||||
struct CRC32 {
|
||||
CRC32() { reset(); }
|
||||
CRC32(const void* values, uint size) : CRC32() { data(values, size); }
|
||||
CRC32(const vector<uint8_t>& values) : CRC32() { data(values); }
|
||||
CRC32(const string& values) : CRC32() { data(values); }
|
||||
struct CRC32 : Hash {
|
||||
nallHash(CRC32)
|
||||
|
||||
auto reset() -> void {
|
||||
auto reset() -> void override {
|
||||
checksum = ~0;
|
||||
}
|
||||
|
||||
auto data(uint8_t value) -> void {
|
||||
auto input(uint8_t value) -> void override {
|
||||
checksum = (checksum >> 8) ^ table(checksum ^ value);
|
||||
}
|
||||
|
||||
auto data(const void* values, uint size) -> void {
|
||||
auto p = (const uint8_t*)values;
|
||||
while(size--) data(*p++);
|
||||
}
|
||||
|
||||
auto data(const vector<uint8_t>& values) -> void {
|
||||
for(auto value : values) data(value);
|
||||
}
|
||||
|
||||
auto data(const string& values) -> void {
|
||||
for(auto value : values) data(value);
|
||||
auto output() const -> vector<uint8_t> {
|
||||
vector<uint8_t> result;
|
||||
for(auto n : rrange(4)) result.append(~checksum >> n * 8);
|
||||
return result;
|
||||
}
|
||||
|
||||
auto value() const -> uint32_t {
|
||||
return ~checksum;
|
||||
}
|
||||
|
||||
inline auto digest() const -> string {
|
||||
return hex(value(), 8L);
|
||||
}
|
||||
|
||||
private:
|
||||
static auto table(uint8_t index) -> uint32_t {
|
||||
static uint32_t table[256] = {0};
|
||||
@@ -59,7 +44,7 @@ private:
|
||||
return table[index];
|
||||
}
|
||||
|
||||
uint32_t checksum;
|
||||
uint32_t checksum = 0;
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
@@ -1,45 +1,30 @@
|
||||
#pragma once
|
||||
|
||||
#include <nall/range.hpp>
|
||||
#include <nall/string.hpp>
|
||||
#include <nall/hash/hash.hpp>
|
||||
|
||||
namespace nall { namespace Hash {
|
||||
|
||||
struct CRC64 {
|
||||
CRC64() { reset(); }
|
||||
CRC64(const void* values, uint size) : CRC64() { data(values, size); }
|
||||
CRC64(const vector<uint8_t>& values) : CRC64() { data(values); }
|
||||
CRC64(const string& values) : CRC64() { data(values); }
|
||||
struct CRC64 : Hash {
|
||||
nallHash(CRC64)
|
||||
|
||||
auto reset() -> void {
|
||||
auto reset() -> void override {
|
||||
checksum = ~0;
|
||||
}
|
||||
|
||||
auto data(uint8_t value) -> void {
|
||||
auto input(uint8_t value) -> void override {
|
||||
checksum = (checksum >> 8) ^ table(checksum ^ value);
|
||||
}
|
||||
|
||||
auto data(const void* values, uint size) -> void {
|
||||
auto p = (const uint8_t*)values;
|
||||
while(size--) data(*p++);
|
||||
}
|
||||
|
||||
auto data(const vector<uint8_t>& values) -> void {
|
||||
for(auto value : values) data(value);
|
||||
}
|
||||
|
||||
auto data(const string& values) -> void {
|
||||
for(auto value : values) data(value);
|
||||
auto output() const -> vector<uint8_t> {
|
||||
vector<uint8_t> result;
|
||||
for(auto n : rrange(8)) result.append(~checksum >> n * 8);
|
||||
return result;
|
||||
}
|
||||
|
||||
auto value() const -> uint64_t {
|
||||
return ~checksum;
|
||||
}
|
||||
|
||||
inline auto digest() const -> string {
|
||||
return hex(value(), 16L);
|
||||
}
|
||||
|
||||
private:
|
||||
static auto table(uint8_t index) -> uint64_t {
|
||||
static uint64_t table[256] = {0};
|
||||
@@ -59,7 +44,7 @@ private:
|
||||
return table[index];
|
||||
}
|
||||
|
||||
uint64_t checksum;
|
||||
uint64_t checksum = 0;
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
43
nall/hash/hash.hpp
Normal file
43
nall/hash/hash.hpp
Normal file
@@ -0,0 +1,43 @@
|
||||
#pragma once
|
||||
|
||||
#include <nall/arithmetic.hpp>
|
||||
#include <nall/range.hpp>
|
||||
#include <nall/string.hpp>
|
||||
|
||||
//cannot use constructor inheritance due to needing to call virtual reset();
|
||||
//instead, define a macro to reduce boilerplate code in every Hash subclass
|
||||
#define nallHash(Name) \
|
||||
Name() { reset(); } \
|
||||
Name(const void* data, uint64_t size) : Name() { input(data, size); } \
|
||||
Name(const vector<uint8_t>& data) : Name() { input(data); } \
|
||||
Name(const string& data) : Name() { input(data); } \
|
||||
using Hash::input; \
|
||||
|
||||
namespace nall { namespace Hash {
|
||||
|
||||
struct Hash {
|
||||
virtual auto reset() -> void = 0;
|
||||
virtual auto input(uint8_t data) -> void = 0;
|
||||
virtual auto output() const -> vector<uint8_t> = 0;
|
||||
|
||||
auto input(const void* data, uint64_t size) -> void {
|
||||
auto p = (const uint8_t*)data;
|
||||
while(size--) input(*p++);
|
||||
}
|
||||
|
||||
auto input(const vector<uint8_t>& data) -> void {
|
||||
for(auto byte : data) input(byte);
|
||||
}
|
||||
|
||||
auto input(const string& data) -> void {
|
||||
for(auto byte : data) input(byte);
|
||||
}
|
||||
|
||||
auto digest() const -> string {
|
||||
string result;
|
||||
for(auto n : output()) result.append(hex(n, 2L));
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
}}
|
||||
101
nall/hash/sha224.hpp
Normal file
101
nall/hash/sha224.hpp
Normal file
@@ -0,0 +1,101 @@
|
||||
#pragma once
|
||||
|
||||
#include <nall/hash/hash.hpp>
|
||||
|
||||
namespace nall { namespace Hash {
|
||||
|
||||
struct SHA224 : Hash {
|
||||
nallHash(SHA224)
|
||||
|
||||
auto reset() -> void override {
|
||||
for(auto& n : queue) n = 0;
|
||||
for(auto& n : w) n = 0;
|
||||
for(auto n : range(8)) h[n] = square(n);
|
||||
queued = length = 0;
|
||||
}
|
||||
|
||||
auto input(uint8_t value) -> void override {
|
||||
byte(value);
|
||||
length++;
|
||||
}
|
||||
|
||||
auto output() const -> vector<uint8_t> override {
|
||||
SHA224 self(*this);
|
||||
self.finish();
|
||||
vector<uint8_t> result;
|
||||
for(auto h : range(7)) {
|
||||
for(auto n : rrange(4)) result.append(self.h[h] >> n * 8);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
auto value() const -> uint256_t {
|
||||
uint256_t value = 0;
|
||||
for(auto byte : output()) value = value << 8 | byte;
|
||||
return value;
|
||||
}
|
||||
|
||||
private:
|
||||
auto byte(uint8_t value) -> void {
|
||||
uint32_t shift = (3 - (queued & 3)) * 8;
|
||||
queue[queued >> 2] &= ~(0xff << shift);
|
||||
queue[queued >> 2] |= (value << shift);
|
||||
if(++queued == 64) block(), queued = 0;
|
||||
}
|
||||
|
||||
auto block() -> void {
|
||||
for(auto n : range(16)) w[n] = queue[n];
|
||||
for(auto n : range(16, 64)) {
|
||||
uint32_t a = ror(w[n - 15], 7) ^ ror(w[n - 15], 18) ^ (w[n - 15] >> 3);
|
||||
uint32_t b = ror(w[n - 2], 17) ^ ror(w[n - 2], 19) ^ (w[n - 2] >> 10);
|
||||
w[n] = w[n - 16] + w[n - 7] + a + b;
|
||||
}
|
||||
uint32_t t[8];
|
||||
for(auto n : range(8)) t[n] = h[n];
|
||||
for(auto n : range(64)) {
|
||||
uint32_t a = ror(t[0], 2) ^ ror(t[0], 13) ^ ror(t[0], 22);
|
||||
uint32_t b = ror(t[4], 6) ^ ror(t[4], 11) ^ ror(t[4], 25);
|
||||
uint32_t c = (t[0] & t[1]) ^ (t[0] & t[2]) ^ (t[1] & t[2]);
|
||||
uint32_t d = (t[4] & t[5]) ^ (~t[4] & t[6]);
|
||||
uint32_t e = t[7] + w[n] + cube(n) + b + d;
|
||||
t[7] = t[6]; t[6] = t[5]; t[5] = t[4]; t[4] = t[3] + e;
|
||||
t[3] = t[2]; t[2] = t[1]; t[1] = t[0]; t[0] = a + c + e;
|
||||
}
|
||||
for(auto n : range(8)) h[n] += t[n];
|
||||
}
|
||||
|
||||
auto finish() -> void {
|
||||
byte(0x80);
|
||||
while(queued != 56) byte(0x00);
|
||||
for(auto n : range(8)) byte(length * 8 >> (7 - n) * 8);
|
||||
}
|
||||
|
||||
auto square(uint n) -> uint32_t {
|
||||
static const uint32_t value[8] = {
|
||||
0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,
|
||||
};
|
||||
return value[n];
|
||||
}
|
||||
|
||||
auto cube(uint n) -> uint32_t {
|
||||
static const uint32_t value[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,
|
||||
};
|
||||
return value[n];
|
||||
}
|
||||
|
||||
uint32_t queue[16] = {0};
|
||||
uint32_t w[64] = {0};
|
||||
uint32_t h[8] = {0};
|
||||
uint32_t queued = 0;
|
||||
uint64_t length = 0;
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -1,66 +1,50 @@
|
||||
#pragma once
|
||||
|
||||
#include <nall/range.hpp>
|
||||
#include <nall/string.hpp>
|
||||
#include <nall/hash/hash.hpp>
|
||||
|
||||
namespace nall { namespace Hash {
|
||||
|
||||
struct SHA256 {
|
||||
SHA256() { reset(); }
|
||||
SHA256(const void* values, uint size) : SHA256() { data(values, size); }
|
||||
SHA256(const vector<uint8_t>& values) : SHA256() { data(values); }
|
||||
SHA256(const string& values) : SHA256() { data(values); }
|
||||
struct SHA256 : Hash {
|
||||
nallHash(SHA256)
|
||||
|
||||
auto reset() -> void {
|
||||
for(auto n : input) n = 0;
|
||||
for(auto n : w) n = 0;
|
||||
for(auto n : range(8)) h[n] = square(n);
|
||||
auto reset() -> void override {
|
||||
for(auto& n : queue) n = 0;
|
||||
for(auto& n : w) n = 0;
|
||||
for(auto n : range(8)) h[n] = square(n);
|
||||
queued = length = 0;
|
||||
}
|
||||
|
||||
auto data(uint8_t value) -> void {
|
||||
auto input(uint8_t value) -> void override {
|
||||
byte(value);
|
||||
length++;
|
||||
}
|
||||
|
||||
auto data(const void* values, uint size) -> void {
|
||||
length += size;
|
||||
auto p = (const uint8_t*)values;
|
||||
while(size--) byte(*p++);
|
||||
}
|
||||
|
||||
auto data(const vector<uint8_t>& values) -> void {
|
||||
for(auto value : values) data(value);
|
||||
}
|
||||
|
||||
auto data(const string& values) -> void {
|
||||
for(auto value : values) data(value);
|
||||
}
|
||||
|
||||
auto value() const -> vector<uint8_t> {
|
||||
auto output() const -> vector<uint8_t> override {
|
||||
SHA256 self(*this);
|
||||
self.finish();
|
||||
vector<uint8_t> result;
|
||||
for(auto n : range(32)) result.append(self.h[n >> 2] >> ((3 - (n & 3)) << 3));
|
||||
for(auto h : self.h) {
|
||||
for(auto n : rrange(4)) result.append(h >> n * 8);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
inline auto digest() const -> string {
|
||||
string result;
|
||||
for(auto n : value()) result.append(hex(n, 2L));
|
||||
return result;
|
||||
auto value() const -> uint256_t {
|
||||
uint256_t value = 0;
|
||||
for(auto byte : output()) value = value << 8 | byte;
|
||||
return value;
|
||||
}
|
||||
|
||||
private:
|
||||
auto byte(uint8_t value) -> void {
|
||||
auto shift = (3 - (queued & 3)) * 8;
|
||||
input[queued >> 2] &= ~(0xff << shift);
|
||||
input[queued >> 2] |= (value << shift);
|
||||
uint32_t shift = (3 - (queued & 3)) * 8;
|
||||
queue[queued >> 2] &= ~(0xff << shift);
|
||||
queue[queued >> 2] |= (value << shift);
|
||||
if(++queued == 64) block(), queued = 0;
|
||||
}
|
||||
|
||||
auto block() -> void {
|
||||
for(auto n : range(16)) w[n] = input[n];
|
||||
for(auto n : range(16)) w[n] = queue[n];
|
||||
for(auto n : range(16, 64)) {
|
||||
uint32_t a = ror(w[n - 15], 7) ^ ror(w[n - 15], 18) ^ (w[n - 15] >> 3);
|
||||
uint32_t b = ror(w[n - 2], 17) ^ ror(w[n - 2], 19) ^ (w[n - 2] >> 10);
|
||||
@@ -83,11 +67,7 @@ private:
|
||||
auto finish() -> void {
|
||||
byte(0x80);
|
||||
while(queued != 56) byte(0x00);
|
||||
for(auto n : range(8)) byte((length << 3) >> ((7 - n) << 3));
|
||||
}
|
||||
|
||||
auto ror(uint32_t x, uint32_t n) -> uint32_t {
|
||||
return (x >> n) | (x << 32 - n);
|
||||
for(auto n : range(8)) byte(length * 8 >> (7 - n) * 8);
|
||||
}
|
||||
|
||||
auto square(uint n) -> uint32_t {
|
||||
@@ -111,11 +91,11 @@ private:
|
||||
return value[n];
|
||||
}
|
||||
|
||||
uint32_t input[16];
|
||||
uint32_t queued;
|
||||
uint32_t w[64];
|
||||
uint32_t h[8];
|
||||
uint64_t length;
|
||||
uint32_t queue[16] = {0};
|
||||
uint32_t w[64] = {0};
|
||||
uint32_t h[8] = {0};
|
||||
uint32_t queued = 0;
|
||||
uint64_t length = 0;
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
114
nall/hash/sha384.hpp
Normal file
114
nall/hash/sha384.hpp
Normal file
@@ -0,0 +1,114 @@
|
||||
#pragma once
|
||||
|
||||
#include <nall/hash/hash.hpp>
|
||||
|
||||
namespace nall { namespace Hash {
|
||||
|
||||
struct SHA384 : Hash {
|
||||
nallHash(SHA384)
|
||||
|
||||
auto reset() -> void override {
|
||||
for(auto& n : queue) n = 0;
|
||||
for(auto& n : w) n = 0;
|
||||
for(auto n : range(8)) h[n] = square(n);
|
||||
queued = length = 0;
|
||||
}
|
||||
|
||||
auto input(uint8_t data) -> void override {
|
||||
byte(data);
|
||||
length++;
|
||||
}
|
||||
|
||||
auto output() const -> vector<uint8_t> override {
|
||||
SHA384 self(*this);
|
||||
self.finish();
|
||||
vector<uint8_t> result;
|
||||
for(auto h : range(6)) {
|
||||
for(auto n : rrange(8)) result.append(self.h[h] >> n * 8);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
auto value() const -> uint512_t {
|
||||
uint512_t value = 0;
|
||||
for(auto byte : output()) value = value << 8 | byte;
|
||||
return value;
|
||||
}
|
||||
|
||||
private:
|
||||
auto byte(uint8_t data) -> void {
|
||||
uint64_t shift = (7 - (queued & 7)) * 8;
|
||||
queue[queued >> 3] &=~((uint64_t)0xff << shift);
|
||||
queue[queued >> 3] |= ((uint64_t)data << shift);
|
||||
if(++queued == 128) block(), queued = 0;
|
||||
}
|
||||
|
||||
auto block() -> void {
|
||||
for(auto n : range(16)) w[n] = queue[n];
|
||||
for(auto n : range(16, 80)) {
|
||||
uint64_t a = ror(w[n - 15], 1) ^ ror(w[n - 15], 8) ^ (w[n - 15] >> 7);
|
||||
uint64_t b = ror(w[n - 2], 19) ^ ror(w[n - 2], 61) ^ (w[n - 2] >> 6);
|
||||
w[n] = w[n - 16] + w[n - 7] + a + b;
|
||||
}
|
||||
uint64_t t[8];
|
||||
for(auto n : range(8)) t[n] = h[n];
|
||||
for(auto n : range(80)) {
|
||||
uint64_t a = ror(t[0], 28) ^ ror(t[0], 34) ^ ror(t[0], 39);
|
||||
uint64_t b = ror(t[4], 14) ^ ror(t[4], 18) ^ ror(t[4], 41);
|
||||
uint64_t c = (t[0] & t[1]) ^ (t[0] & t[2]) ^ (t[1] & t[2]);
|
||||
uint64_t d = (t[4] & t[5]) ^ (~t[4] & t[6]);
|
||||
uint64_t e = t[7] + w[n] + cube(n) + b + d;
|
||||
t[7] = t[6]; t[6] = t[5]; t[5] = t[4]; t[4] = t[3] + e;
|
||||
t[3] = t[2]; t[2] = t[1]; t[1] = t[0]; t[0] = a + c + e;
|
||||
}
|
||||
for(auto n : range(8)) h[n] += t[n];
|
||||
}
|
||||
|
||||
auto finish() -> void {
|
||||
byte(0x80);
|
||||
while(queued != 112) byte(0x00);
|
||||
for(auto n : range(16)) byte(length * 8 >> (15 - n) * 8);
|
||||
}
|
||||
|
||||
auto square(uint n) -> uint64_t {
|
||||
static const uint64_t data[8] = {
|
||||
0xcbbb9d5dc1059ed8, 0x629a292a367cd507, 0x9159015a3070dd17, 0x152fecd8f70e5939,
|
||||
0x67332667ffc00b31, 0x8eb44a8768581511, 0xdb0c2e0d64f98fa7, 0x47b5481dbefa4fa4,
|
||||
};
|
||||
return data[n];
|
||||
}
|
||||
|
||||
auto cube(uint n) -> uint64_t {
|
||||
static const uint64_t data[80] = {
|
||||
0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc,
|
||||
0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118,
|
||||
0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2,
|
||||
0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 0xc19bf174cf692694,
|
||||
0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65,
|
||||
0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5,
|
||||
0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4,
|
||||
0xc6e00bf33da88fc2, 0xd5a79147930aa725, 0x06ca6351e003826f, 0x142929670a0e6e70,
|
||||
0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df,
|
||||
0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b,
|
||||
0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30,
|
||||
0xd192e819d6ef5218, 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8,
|
||||
0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8,
|
||||
0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3,
|
||||
0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec,
|
||||
0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b,
|
||||
0xca273eceea26619c, 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178,
|
||||
0x06f067aa72176fba, 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b,
|
||||
0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c,
|
||||
0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817,
|
||||
};
|
||||
return data[n];
|
||||
}
|
||||
|
||||
uint64_t queue[16] = {0};
|
||||
uint64_t w[80] = {0};
|
||||
uint64_t h[8] = {0};
|
||||
uint64_t queued = 0;
|
||||
uint128_t length = 0;
|
||||
};
|
||||
|
||||
}}
|
||||
114
nall/hash/sha512.hpp
Normal file
114
nall/hash/sha512.hpp
Normal file
@@ -0,0 +1,114 @@
|
||||
#pragma once
|
||||
|
||||
#include <nall/hash/hash.hpp>
|
||||
|
||||
namespace nall { namespace Hash {
|
||||
|
||||
struct SHA512 : Hash {
|
||||
nallHash(SHA512)
|
||||
|
||||
auto reset() -> void override {
|
||||
for(auto& n : queue) n = 0;
|
||||
for(auto& n : w) n = 0;
|
||||
for(auto n : range(8)) h[n] = square(n);
|
||||
queued = length = 0;
|
||||
}
|
||||
|
||||
auto input(uint8_t data) -> void override {
|
||||
byte(data);
|
||||
length++;
|
||||
}
|
||||
|
||||
auto output() const -> vector<uint8_t> override {
|
||||
SHA512 self(*this);
|
||||
self.finish();
|
||||
vector<uint8_t> result;
|
||||
for(auto h : self.h) {
|
||||
for(auto n : rrange(8)) result.append(h >> n * 8);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
auto value() const -> uint512_t {
|
||||
uint512_t value = 0;
|
||||
for(auto byte : output()) value = value << 8 | byte;
|
||||
return value;
|
||||
}
|
||||
|
||||
private:
|
||||
auto byte(uint8_t data) -> void {
|
||||
uint64_t shift = (7 - (queued & 7)) * 8;
|
||||
queue[queued >> 3] &=~((uint64_t)0xff << shift);
|
||||
queue[queued >> 3] |= ((uint64_t)data << shift);
|
||||
if(++queued == 128) block(), queued = 0;
|
||||
}
|
||||
|
||||
auto block() -> void {
|
||||
for(auto n : range(16)) w[n] = queue[n];
|
||||
for(auto n : range(16, 80)) {
|
||||
uint64_t a = ror(w[n - 15], 1) ^ ror(w[n - 15], 8) ^ (w[n - 15] >> 7);
|
||||
uint64_t b = ror(w[n - 2], 19) ^ ror(w[n - 2], 61) ^ (w[n - 2] >> 6);
|
||||
w[n] = w[n - 16] + w[n - 7] + a + b;
|
||||
}
|
||||
uint64_t t[8];
|
||||
for(auto n : range(8)) t[n] = h[n];
|
||||
for(auto n : range(80)) {
|
||||
uint64_t a = ror(t[0], 28) ^ ror(t[0], 34) ^ ror(t[0], 39);
|
||||
uint64_t b = ror(t[4], 14) ^ ror(t[4], 18) ^ ror(t[4], 41);
|
||||
uint64_t c = (t[0] & t[1]) ^ (t[0] & t[2]) ^ (t[1] & t[2]);
|
||||
uint64_t d = (t[4] & t[5]) ^ (~t[4] & t[6]);
|
||||
uint64_t e = t[7] + w[n] + cube(n) + b + d;
|
||||
t[7] = t[6]; t[6] = t[5]; t[5] = t[4]; t[4] = t[3] + e;
|
||||
t[3] = t[2]; t[2] = t[1]; t[1] = t[0]; t[0] = a + c + e;
|
||||
}
|
||||
for(auto n : range(8)) h[n] += t[n];
|
||||
}
|
||||
|
||||
auto finish() -> void {
|
||||
byte(0x80);
|
||||
while(queued != 112) byte(0x00);
|
||||
for(auto n : range(16)) byte(length * 8 >> (15 - n) * 8);
|
||||
}
|
||||
|
||||
auto square(uint n) -> uint64_t {
|
||||
static const uint64_t data[8] = {
|
||||
0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1,
|
||||
0x510e527fade682d1, 0x9b05688c2b3e6c1f, 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179,
|
||||
};
|
||||
return data[n];
|
||||
}
|
||||
|
||||
auto cube(uint n) -> uint64_t {
|
||||
static const uint64_t data[80] = {
|
||||
0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc,
|
||||
0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118,
|
||||
0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2,
|
||||
0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 0xc19bf174cf692694,
|
||||
0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65,
|
||||
0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5,
|
||||
0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4,
|
||||
0xc6e00bf33da88fc2, 0xd5a79147930aa725, 0x06ca6351e003826f, 0x142929670a0e6e70,
|
||||
0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df,
|
||||
0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b,
|
||||
0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30,
|
||||
0xd192e819d6ef5218, 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8,
|
||||
0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8,
|
||||
0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3,
|
||||
0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec,
|
||||
0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b,
|
||||
0xca273eceea26619c, 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178,
|
||||
0x06f067aa72176fba, 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b,
|
||||
0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c,
|
||||
0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817,
|
||||
};
|
||||
return data[n];
|
||||
}
|
||||
|
||||
uint64_t queue[16] = {0};
|
||||
uint64_t w[80] = {0};
|
||||
uint64_t h[8] = {0};
|
||||
uint64_t queued = 0;
|
||||
uint128_t length = 0;
|
||||
};
|
||||
|
||||
}}
|
||||
Reference in New Issue
Block a user