diff --git a/.gitmodules b/.gitmodules index 3c88933..e69de29 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +0,0 @@ -[submodule "tests/roms/nes-test-roms"] - path = tests/roms/test-roms - url = git@github.com:christopherpow/nes-test-roms.git diff --git a/extern/sha1/README.md b/extern/sha1/README.md new file mode 100644 index 0000000..2805803 --- /dev/null +++ b/extern/sha1/README.md @@ -0,0 +1,23 @@ +Taken from https://github.com/SourMesen/Mesen2/blob/master/Utilities/sha1.cpp + +/* + sha1.hpp - source code of + + ============ + SHA-1 in C++ + ============ + + 100% Public Domain. + + Original C Code + -- Steve Reid + Small changes to fit into bglibs + -- Bruce Guenter + Translation to simpler C++ Code + -- Volker Diels-Grabsch + Safety fixes + -- Eugene Hopkinson + Header-only library + -- Zlatko Michailov +*/ + diff --git a/extern/sha1/sha1.cpp b/extern/sha1/sha1.cpp new file mode 100644 index 0000000..eaf60ac --- /dev/null +++ b/extern/sha1/sha1.cpp @@ -0,0 +1,319 @@ +/* + sha1.cpp - source code of + + ============ + SHA-1 in C++ + ============ + + 100% Public Domain. + + Original C Code + -- Steve Reid + Small changes to fit into bglibs + -- Bruce Guenter + Translation to simpler C++ Code + -- Volker Grabsch + Safety fixes + -- Eugene Hopkinson +*/ + +#include "sha1.h" +#include +#include +#include +#include + +static const size_t BLOCK_INTS = 16; /* number of 32bit integers per SHA1 block */ +static const size_t BLOCK_BYTES = BLOCK_INTS * 4; + + +static void reset(uint32_t digest[], std::string &buffer, uint64_t &transforms) +{ + /* SHA1 initialization constants */ + digest[0] = 0x67452301; + digest[1] = 0xefcdab89; + digest[2] = 0x98badcfe; + digest[3] = 0x10325476; + digest[4] = 0xc3d2e1f0; + + /* Reset counters */ + buffer = ""; + transforms = 0; +} + + +static uint32_t rol(const uint32_t value, const size_t bits) +{ + return (value << bits) | (value >> (32 - bits)); +} + + +static uint32_t blk(const uint32_t block[BLOCK_INTS], const size_t i) +{ + return rol(block[(i + 13) & 15] ^ block[(i + 8) & 15] ^ block[(i + 2) & 15] ^ block[i], 1); +} + + +/* + * (R0+R1), R2, R3, R4 are the different operations used in SHA1 + */ + +static void R0(const uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i) +{ + z += ((w&(x^y)) ^ y) + block[i] + 0x5a827999 + rol(v, 5); + w = rol(w, 30); +} + + +static void R1(uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i) +{ + block[i] = blk(block, i); + z += ((w&(x^y)) ^ y) + block[i] + 0x5a827999 + rol(v, 5); + w = rol(w, 30); +} + + +static void R2(uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i) +{ + block[i] = blk(block, i); + z += (w^x^y) + block[i] + 0x6ed9eba1 + rol(v, 5); + w = rol(w, 30); +} + + +static void R3(uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i) +{ + block[i] = blk(block, i); + z += (((w | x)&y) | (w&x)) + block[i] + 0x8f1bbcdc + rol(v, 5); + w = rol(w, 30); +} + + +static void R4(uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i) +{ + block[i] = blk(block, i); + z += (w^x^y) + block[i] + 0xca62c1d6 + rol(v, 5); + w = rol(w, 30); +} + + +/* + * Hash a single 512-bit block. This is the core of the algorithm. + */ + +static void transform(uint32_t digest[], uint32_t block[BLOCK_INTS], uint64_t &transforms) +{ + /* Copy digest[] to working vars */ + uint32_t a = digest[0]; + uint32_t b = digest[1]; + uint32_t c = digest[2]; + uint32_t d = digest[3]; + uint32_t e = digest[4]; + + /* 4 rounds of 20 operations each. Loop unrolled. */ + R0(block, a, b, c, d, e, 0); + R0(block, e, a, b, c, d, 1); + R0(block, d, e, a, b, c, 2); + R0(block, c, d, e, a, b, 3); + R0(block, b, c, d, e, a, 4); + R0(block, a, b, c, d, e, 5); + R0(block, e, a, b, c, d, 6); + R0(block, d, e, a, b, c, 7); + R0(block, c, d, e, a, b, 8); + R0(block, b, c, d, e, a, 9); + R0(block, a, b, c, d, e, 10); + R0(block, e, a, b, c, d, 11); + R0(block, d, e, a, b, c, 12); + R0(block, c, d, e, a, b, 13); + R0(block, b, c, d, e, a, 14); + R0(block, a, b, c, d, e, 15); + R1(block, e, a, b, c, d, 0); + R1(block, d, e, a, b, c, 1); + R1(block, c, d, e, a, b, 2); + R1(block, b, c, d, e, a, 3); + R2(block, a, b, c, d, e, 4); + R2(block, e, a, b, c, d, 5); + R2(block, d, e, a, b, c, 6); + R2(block, c, d, e, a, b, 7); + R2(block, b, c, d, e, a, 8); + R2(block, a, b, c, d, e, 9); + R2(block, e, a, b, c, d, 10); + R2(block, d, e, a, b, c, 11); + R2(block, c, d, e, a, b, 12); + R2(block, b, c, d, e, a, 13); + R2(block, a, b, c, d, e, 14); + R2(block, e, a, b, c, d, 15); + R2(block, d, e, a, b, c, 0); + R2(block, c, d, e, a, b, 1); + R2(block, b, c, d, e, a, 2); + R2(block, a, b, c, d, e, 3); + R2(block, e, a, b, c, d, 4); + R2(block, d, e, a, b, c, 5); + R2(block, c, d, e, a, b, 6); + R2(block, b, c, d, e, a, 7); + R3(block, a, b, c, d, e, 8); + R3(block, e, a, b, c, d, 9); + R3(block, d, e, a, b, c, 10); + R3(block, c, d, e, a, b, 11); + R3(block, b, c, d, e, a, 12); + R3(block, a, b, c, d, e, 13); + R3(block, e, a, b, c, d, 14); + R3(block, d, e, a, b, c, 15); + R3(block, c, d, e, a, b, 0); + R3(block, b, c, d, e, a, 1); + R3(block, a, b, c, d, e, 2); + R3(block, e, a, b, c, d, 3); + R3(block, d, e, a, b, c, 4); + R3(block, c, d, e, a, b, 5); + R3(block, b, c, d, e, a, 6); + R3(block, a, b, c, d, e, 7); + R3(block, e, a, b, c, d, 8); + R3(block, d, e, a, b, c, 9); + R3(block, c, d, e, a, b, 10); + R3(block, b, c, d, e, a, 11); + R4(block, a, b, c, d, e, 12); + R4(block, e, a, b, c, d, 13); + R4(block, d, e, a, b, c, 14); + R4(block, c, d, e, a, b, 15); + R4(block, b, c, d, e, a, 0); + R4(block, a, b, c, d, e, 1); + R4(block, e, a, b, c, d, 2); + R4(block, d, e, a, b, c, 3); + R4(block, c, d, e, a, b, 4); + R4(block, b, c, d, e, a, 5); + R4(block, a, b, c, d, e, 6); + R4(block, e, a, b, c, d, 7); + R4(block, d, e, a, b, c, 8); + R4(block, c, d, e, a, b, 9); + R4(block, b, c, d, e, a, 10); + R4(block, a, b, c, d, e, 11); + R4(block, e, a, b, c, d, 12); + R4(block, d, e, a, b, c, 13); + R4(block, c, d, e, a, b, 14); + R4(block, b, c, d, e, a, 15); + + /* Add the working vars back into digest[] */ + digest[0] += a; + digest[1] += b; + digest[2] += c; + digest[3] += d; + digest[4] += e; + + /* Count the number of transformations */ + transforms++; +} + + +static void buffer_to_block(const std::string &buffer, uint32_t block[BLOCK_INTS]) +{ + /* Convert the std::string (byte buffer) to a uint32_t array (MSB) */ + for(size_t i = 0; i < BLOCK_INTS; i++) { + block[i] = (buffer[4 * i + 3] & 0xff) + | (buffer[4 * i + 2] & 0xff) << 8 + | (buffer[4 * i + 1] & 0xff) << 16 + | (buffer[4 * i + 0] & 0xff) << 24; + } +} + + +SHA1::SHA1() +{ + reset(digest, buffer, transforms); +} + + +void SHA1::update(const std::string &s) +{ + std::istringstream is(s); + update(is); +} + + +void SHA1::update(std::istream &is) +{ + char sbuf[BLOCK_BYTES]; + uint32_t block[BLOCK_INTS]; + + while(true) { + is.read(sbuf, BLOCK_BYTES - buffer.size()); + buffer.append(sbuf, (size_t)is.gcount()); + if(buffer.size() != BLOCK_BYTES) { + return; + } + + buffer_to_block(buffer, block); + transform(digest, block, transforms); + buffer.clear(); + } +} + + +/* + * Add padding and return the message digest. + */ + +std::string SHA1::final() +{ + /* Total number of hashed bits */ + uint64_t total_bits = (transforms*BLOCK_BYTES + buffer.size()) * 8; + + /* Padding */ + buffer += (char)0x80; + size_t orig_size = buffer.size(); + while(buffer.size() < BLOCK_BYTES) { + buffer += (char)0x00; + } + + uint32_t block[BLOCK_INTS]; + buffer_to_block(buffer, block); + + if(orig_size > BLOCK_BYTES - 8) { + transform(digest, block, transforms); + for(size_t i = 0; i < BLOCK_INTS - 2; i++) { + block[i] = 0; + } + } + + /* Append total_bits, split this uint64_t into two uint32_t */ + block[BLOCK_INTS - 1] = (uint32_t)total_bits; + block[BLOCK_INTS - 2] = (uint32_t)(total_bits >> 32); + transform(digest, block, transforms); + + /* Hex std::string */ + std::ostringstream result; + for(size_t i = 0; i < sizeof(digest) / sizeof(digest[0]); i++) { + result << std::uppercase << std::hex << std::setfill('0') << std::setw(8); + result << digest[i]; + } + + /* Reset for next run */ + reset(digest, buffer, transforms); + + return result.str(); +} + + +std::string SHA1::GetHash(uint8_t* data, size_t size) +{ + std::stringstream ss; + ss.write((char*)data, size); + + SHA1 checksum; + checksum.update(ss); + return checksum.final(); +} + +std::string SHA1::GetHash(std::istream &stream) +{ + SHA1 checksum; + checksum.update(stream); + return checksum.final(); +} + +std::string SHA1::GetHash(const std::string &filename) +{ + std::ifstream stream(filename.c_str(), std::ios::binary); + SHA1 checksum; + checksum.update(stream); + return checksum.final(); +} diff --git a/extern/sha1/sha1.h b/extern/sha1/sha1.h new file mode 100644 index 0000000..a9f5e90 --- /dev/null +++ b/extern/sha1/sha1.h @@ -0,0 +1,41 @@ +/* + sha1.h - header of + + ============ + SHA-1 in C++ + ============ + + 100% Public Domain. + + Original C Code + -- Steve Reid + Small changes to fit into bglibs + -- Bruce Guenter + Translation to simpler C++ Code + -- Volker Grabsch + Safety fixes + -- Eugene Hopkinson +*/ + +#pragma once + +#include +#include +#include + +class SHA1 +{ +public: + SHA1(); + void update(const std::string &s); + void update(std::istream &is); + std::string final(); + static std::string GetHash(const std::string &filename); + static std::string GetHash(std::istream &stream); + static std::string GetHash(uint8_t* data, size_t size); + +private: + uint32_t digest[5]; + std::string buffer; + uint64_t transforms; +}; diff --git a/meson.build b/meson.build index 99de1f1..6b938c9 100644 --- a/meson.build +++ b/meson.build @@ -35,7 +35,8 @@ quickerNESCoreSrc = [ 'source/core/Multi_Buffer.cpp', 'source/core/Nes_Emu.cpp', 'source/core/nes_ntsc.cpp', - 'source/core/Nes_Vrc7.cpp', + 'source/core/Nes_Vrc7.cpp', + 'extern/sha1/sha1.cpp' ] # quickerNES Core Configuration diff --git a/tests/endingChecker.cpp b/tests/endingChecker.cpp index daf4c23..da48561 100644 --- a/tests/endingChecker.cpp +++ b/tests/endingChecker.cpp @@ -1,9 +1,36 @@ #include "argparse/argparse.hpp" +#include "sha1/sha1.h" #include "utils.hpp" #include "emuInstance.hpp" +#include int main(int argc, char *argv[]) { + // Parsing command line arguments + argparse::ArgumentParser program("player", "1.0"); + + program.add_argument("romFile") + .help("Path to the rom file to run.") + .required(); + + // Try to parse arguments + try { program.parse_args(argc, argv); } + catch (const std::runtime_error &err) { EXIT_WITH_ERROR("%s\n%s", err.what(), program.help().str().c_str()); } + + // Getting ROM file path + std::string romFilePath = program.get("romFile"); + + // Getting ROM data + std::string romData; + auto status = loadStringFromFile(romData, romFilePath.c_str()); + if (status == false) EXIT_WITH_ERROR("Could not read rom file: '%s'\n", romFilePath.c_str()); + + // Getting SHA1 String + std::string sha1String = SHA1::GetHash((uint8_t*)romData.data(), romData.size()); + + // Printing ROM SHA1 + printf("%s\n", sha1String.c_str()); + return 0; } diff --git a/tests/meson.build b/tests/meson.build index b814c0d..3a41d16 100644 --- a/tests/meson.build +++ b/tests/meson.build @@ -1,6 +1,10 @@ nomalloc = environment({'MALLOC_PERTURB_': '0'}) # Adding game ending checks -endingChecker = executable('endingChecker', files(['endingChecker.cpp']), dependencies: [ quickerNESCoreDependency ] ) +endingChecker = executable('endingChecker', + files(['endingChecker.cpp']), + dependencies: [ quickerNESCoreDependency ] + ) + testSuite = [ 'gameEndings' ] -test('castlevania1AnyPercent', endingChecker, args : ['castlevania1AnyPercent.test'], suite: testSuite) +test('castlevania1AnyPercent', endingChecker, workdir : meson.current_source_dir(), args : ['roms/Castlevania (U) (PRG0) [!].nes'], suite: testSuite) diff --git a/tests/roms/games/.gitignore b/tests/roms/.gitignore similarity index 100% rename from tests/roms/games/.gitignore rename to tests/roms/.gitignore diff --git a/tests/roms/games/README.md b/tests/roms/README.md similarity index 100% rename from tests/roms/games/README.md rename to tests/roms/README.md diff --git a/tests/roms/test-roms b/tests/roms/test-roms deleted file mode 160000 index 95d8f62..0000000 --- a/tests/roms/test-roms +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 95d8f621ae55cee0d09b91519a8989ae0e64753b diff --git a/tests/movies/castlevania1AnyPercent.sol b/tests/sequences/castlevania1AnyPercent.sol similarity index 100% rename from tests/movies/castlevania1AnyPercent.sol rename to tests/sequences/castlevania1AnyPercent.sol