From cba20adff26b3162307ef0c29f6b4a94ddb89577 Mon Sep 17 00:00:00 2001
From: volatilflerovium <easytable@yandex.com>
Date: Sat, 6 Dec 2025 07:42:52 +0000
Subject: [PATCH 1/6] Add CMakeLists.txt Add Compiler flags -g -O3 to MakeFile
 Ignore build and bin directories Add performance.txt

---
 .gitignore      |  2 ++
 CMakeLists.txt  | 66 +++++++++++++++++++++++++++++++++++++++++++++++++
 Makefile        |  4 +--
 README.md       | 28 +++++++++++++++++++++
 README.org      | 17 -------------
 performance.txt |  8 ++++++
 6 files changed, 106 insertions(+), 19 deletions(-)
 create mode 100644 CMakeLists.txt
 create mode 100644 README.md
 delete mode 100644 README.org
 create mode 100644 performance.txt

diff --git a/.gitignore b/.gitignore
index 6416eaa..556cc11 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
 /.vscode/
 /demo_sha1
 /test_sha1
+bin/
+build/
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..9a1e6d1
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,66 @@
+cmake_minimum_required(VERSION 3.18)
+project("SHA1_tests")
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_FLAGS "-Wall")
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+set(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/bin)
+
+get_filename_component(PARENT_DIR ../ ABSOLUTE)
+
+
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+	add_definitions(-D_WIN32)
+	add_compile_options("/O2")
+else()
+	add_definitions(-D_LINUX)
+   if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+		message(WARNING "Assuming system in Linux")
+	endif()
+	add_compile_options("-O3")
+	add_compile_options("-g")
+endif()
+
+#---------------------------------------------------------------------
+
+add_library(SHA1_lib INTERFACE)
+
+target_include_directories(
+	SHA1_lib
+	INTERFACE
+	"${CMAKE_SOURCE_DIR}"
+)
+
+#---------------------------------------------------------------------
+
+set(TEST test_sha1)
+
+add_executable(
+	"${TEST}" 
+	test_sha1.cpp
+	test_sha1_file.cpp
+)
+
+target_link_libraries(
+	"${TEST}"
+	PRIVATE
+	SHA1_lib
+)
+
+#---------------------------------------------------------------------
+
+# Create a 1GB size file for testing performance
+
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+	message("Creating a 1GB file of random data in /tmp directory...")
+	execute_process(COMMAND dd if=/dev/urandom of=/tmp/1G_test_file.txt bs=1G count=1 iflag=fullblock
+		ERROR_VARIABLE error
+		OUTPUT_VARIABLE output
+	)
+
+	add_compile_definitions(TEST_FILE="/tmp/1G_test_file.txt")
+endif()
+
+#---------------------------------------------------------------------
diff --git a/Makefile b/Makefile
index 41fc3c9..a5d6704 100644
--- a/Makefile
+++ b/Makefile
@@ -5,10 +5,10 @@ RM    = rm -f
 all: demo_sha1 test_sha1
 
 demo_sha1: demo_sha1.cpp sha1.cpp sha1.hpp
-	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -Wall -Wextra -std=c++11 -o $@ demo_sha1.cpp sha1.cpp
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -Wall -Wextra -std=c++11 -g -O3 -o $@ demo_sha1.cpp
 
 test_sha1: test_sha1.cpp test_sha1_file.cpp sha1.hpp
-	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -Wall -Wextra -std=c++11 -o $@ test_sha1.cpp test_sha1_file.cpp sha1.cpp
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -Wall -Wextra -std=c++11 -g -O3 -o $@ test_sha1.cpp test_sha1_file.cpp
 
 check: test_sha1
 	./test_sha1
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..03f3b9f
--- /dev/null
+++ b/README.md
@@ -0,0 +1,28 @@
+# SHA-1 implementation in C++
+
+## Warning
+
+Do not use SHA-1 unless you have to! 
+[SHA-1 is practically broken](https://en.wikipedia.org/wiki/SHA-1#Birthday-Near-Collision_Attack_%E2%80%93_first_practical_chosen-prefix_attack). Use a hash function from the [SHA-2](https://en.wikipedia.org/wiki/SHA-2) or [SHA-3](https://en.wikipedia.org/wiki/SHA-3) family instead.
+
+## How to build tests
+
+Using cmake
+```
+mkdir build
+cd build
+cmake ..
+make
+```
+
+## License
+
+100% Public Domain
+
+## Authors
+
+- Steve Reid (Original C Code)
+- [Bruce Guenter](http://untroubled.org/) (Small changes to fit into bglibs)
+- [Volker Diels-Grabsch](https://njh.eu/) (Translation to simpler C++ Code)
+- [Eugene Hopkinson](https://riot.so/) (Safety improvements)
+- [Zlatko Michailov](http://zlatko.michailov.org) (Header-only library)
diff --git a/README.org b/README.org
deleted file mode 100644
index 9c6cb7f..0000000
--- a/README.org
+++ /dev/null
@@ -1,17 +0,0 @@
-* SHA-1 implementation in C++
-
-** Warning
-
-Do not use SHA-1 unless you have to! [[https://en.wikipedia.org/wiki/SHA-1#Birthday-Near-Collision_Attack_%E2%80%93_first_practical_chosen-prefix_attack][SHA-1 is practically broken]]. Use a hash function from the [[https://en.wikipedia.org/wiki/SHA-2][SHA-2]] or [[https://en.wikipedia.org/wiki/SHA-3][SHA-3]] family instead.
-
-** License
-
-100% Public Domain
-
-** Authors
-
-- Steve Reid (Original C Code)
-- [[http://untroubled.org/][Bruce Guenter]] (Small changes to fit into bglibs)
-- [[https://njh.eu/][Volker Diels-Grabsch]] (Translation to simpler C++ Code)
-- [[https://riot.so/][Eugene Hopkinson]] (Safety improvements)
-- [[http://zlatko.michailov.org][Zlatko Michailov]] (Header-only library)
diff --git a/performance.txt b/performance.txt
new file mode 100644
index 0000000..cac5a0e
--- /dev/null
+++ b/performance.txt
@@ -0,0 +1,8 @@
+perf stat ./../bin/test_sha1
+0.011223803 seconds time elapsed
+
+perf stat ./../bin/test_sha1 --slow
+6.446021922 seconds time elapsed
+
+perf stat ./../bin/test_sha1 /tmp/1G_test_file.txt
+1.885112058 seconds time elapsed

From 9abd5f0f028130172db683293e7f4892b1b8a3a2 Mon Sep 17 00:00:00 2001
From: volatilflerovium <easytable@yandex.com>
Date: Sat, 6 Dec 2025 07:54:36 +0000
Subject: [PATCH 2/6] Move all the static function to the SHA1 class scope.

---
 README.md |   1 +
 sha1.hpp  | 130 ++++++++++++++++++++++++++++++------------------------
 2 files changed, 73 insertions(+), 58 deletions(-)

diff --git a/README.md b/README.md
index 03f3b9f..ea98ec8 100644
--- a/README.md
+++ b/README.md
@@ -26,3 +26,4 @@ make
 - [Volker Diels-Grabsch](https://njh.eu/) (Translation to simpler C++ Code)
 - [Eugene Hopkinson](https://riot.so/) (Safety improvements)
 - [Zlatko Michailov](http://zlatko.michailov.org) (Header-only library)
+- [Dan Machado](dan-machado@yandex.com) (Refactoring)
diff --git a/sha1.hpp b/sha1.hpp
index 67a6b52..1e4b5bb 100644
--- a/sha1.hpp
+++ b/sha1.hpp
@@ -17,6 +17,8 @@
         -- Eugene Hopkinson <slowriot at voxelstorm dot com>
     Header-only library
         -- Zlatko Michailov <zlatko@michailov.org>
+    C++ refactoring
+        -- Dan Machado <dan-machado@yandex.com>
 */
 
 #ifndef SHA1_HPP
@@ -40,39 +42,51 @@ class SHA1
     std::string final();
     static std::string from_file(const std::string &filename);
 
-private:
-    uint32_t digest[5];
-    std::string buffer;
+private:    
+
+    static const size_t BLOCK_INTS = 16;  /* number of 32bit integers per SHA1 block */
+    static const size_t BLOCK_BYTES = BLOCK_INTS * 4;
+
+    uint32_t m_digest[5];
+    std::string m_buffer;
     uint64_t transforms;
-};
 
+    void reset(uint32_t m_digest[], std::string &m_buffer, uint64_t &transforms);
+    uint32_t rol(const uint32_t value, const size_t bits);
+    uint32_t blk(const uint32_t block[BLOCK_INTS], const size_t i);
+    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);
+    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);
+    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);
+    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);
+    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);
+    void transform(uint32_t m_digest[], uint32_t block[BLOCK_INTS], uint64_t &transforms);
+    void buffer_to_block(const std::string &m_buffer, uint32_t block[BLOCK_INTS]);
+};
 
-static const size_t BLOCK_INTS = 16;  /* number of 32bit integers per SHA1 block */
-static const size_t BLOCK_BYTES = BLOCK_INTS * 4;
 
 
-inline static void reset(uint32_t digest[], std::string &buffer, uint64_t &transforms)
+inline void SHA1::reset(uint32_t m_digest[], std::string &m_buffer, uint64_t &transforms)
 {
     /* SHA1 initialization constants */
-    digest[0] = 0x67452301;
-    digest[1] = 0xefcdab89;
-    digest[2] = 0x98badcfe;
-    digest[3] = 0x10325476;
-    digest[4] = 0xc3d2e1f0;
+    m_digest[0] = 0x67452301;
+    m_digest[1] = 0xefcdab89;
+    m_digest[2] = 0x98badcfe;
+    m_digest[3] = 0x10325476;
+    m_digest[4] = 0xc3d2e1f0;
 
     /* Reset counters */
-    buffer = "";
+    m_buffer = "";
     transforms = 0;
 }
 
 
-inline static uint32_t rol(const uint32_t value, const size_t bits)
+inline uint32_t SHA1::rol(const uint32_t value, const size_t bits)
 {
     return (value << bits) | (value >> (32 - bits));
 }
 
 
-inline static uint32_t blk(const uint32_t block[BLOCK_INTS], const size_t i)
+inline uint32_t SHA1::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);
 }
@@ -82,14 +96,14 @@ inline static uint32_t blk(const uint32_t block[BLOCK_INTS], const size_t i)
  * (R0+R1), R2, R3, R4 are the different operations used in SHA1
  */
 
-inline 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)
+inline void SHA1::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);
 }
 
 
-inline 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)
+inline void SHA1::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);
@@ -97,7 +111,7 @@ inline static void R1(uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w,
 }
 
 
-inline 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)
+inline void SHA1::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);
@@ -105,7 +119,7 @@ inline static void R2(uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w,
 }
 
 
-inline 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)
+inline void SHA1::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);
@@ -113,7 +127,7 @@ inline static void R3(uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w,
 }
 
 
-inline 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)
+inline void SHA1::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);
@@ -125,14 +139,14 @@ inline static void R4(uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w,
  * Hash a single 512-bit block. This is the core of the algorithm.
  */
 
-inline static void transform(uint32_t digest[], uint32_t block[BLOCK_INTS], uint64_t &transforms)
+inline void SHA1::transform(uint32_t m_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];
+    /* Copy m_digest[] to working vars */
+    uint32_t a = m_digest[0];
+    uint32_t b = m_digest[1];
+    uint32_t c = m_digest[2];
+    uint32_t d = m_digest[3];
+    uint32_t e = m_digest[4];
 
     /* 4 rounds of 20 operations each. Loop unrolled. */
     R0(block, a, b, c, d, e,  0);
@@ -216,34 +230,34 @@ inline static void transform(uint32_t digest[], uint32_t block[BLOCK_INTS], uint
     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;
+    /* Add the working vars back into m_digest[] */
+    m_digest[0] += a;
+    m_digest[1] += b;
+    m_digest[2] += c;
+    m_digest[3] += d;
+    m_digest[4] += e;
 
     /* Count the number of transformations */
     transforms++;
 }
 
 
-inline static void buffer_to_block(const std::string &buffer, uint32_t block[BLOCK_INTS])
+inline void SHA1::buffer_to_block(const std::string &m_buffer, uint32_t block[BLOCK_INTS])
 {
-    /* Convert the std::string (byte buffer) to a uint32_t array (MSB) */
+    /* Convert the std::string (byte m_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;
+        block[i] = (m_buffer[4*i+3] & 0xff)
+                   | (m_buffer[4*i+2] & 0xff)<<8
+                   | (m_buffer[4*i+1] & 0xff)<<16
+                   | (m_buffer[4*i+0] & 0xff)<<24;
     }
 }
 
 
 inline SHA1::SHA1()
 {
-    reset(digest, buffer, transforms);
+    reset(m_digest, m_buffer, transforms);
 }
 
 
@@ -259,43 +273,43 @@ inline void SHA1::update(std::istream &is)
     while (true)
     {
         char sbuf[BLOCK_BYTES];
-        is.read(sbuf, BLOCK_BYTES - buffer.size());
-        buffer.append(sbuf, (std::size_t)is.gcount());
-        if (buffer.size() != BLOCK_BYTES)
+        is.read(sbuf, BLOCK_BYTES - m_buffer.size());
+        m_buffer.append(sbuf, (std::size_t)is.gcount());
+        if (m_buffer.size() != BLOCK_BYTES)
         {
             return;
         }
         uint32_t block[BLOCK_INTS];
-        buffer_to_block(buffer, block);
-        transform(digest, block, transforms);
-        buffer.clear();
+        buffer_to_block(m_buffer, block);
+        transform(m_digest, block, transforms);
+        m_buffer.clear();
     }
 }
 
 
 /*
- * Add padding and return the message digest.
+ * Add padding and return the message m_digest.
  */
 
 inline std::string SHA1::final()
 {
     /* Total number of hashed bits */
-    uint64_t total_bits = (transforms*BLOCK_BYTES + buffer.size()) * 8;
+    uint64_t total_bits = (transforms*BLOCK_BYTES + m_buffer.size()) * 8;
 
     /* Padding */
-    buffer += (char)0x80;
-    size_t orig_size = buffer.size();
-    while (buffer.size() < BLOCK_BYTES)
+    m_buffer += (char)0x80;
+    size_t orig_size = m_buffer.size();
+    while (m_buffer.size() < BLOCK_BYTES)
     {
-        buffer += (char)0x00;
+        m_buffer += (char)0x00;
     }
 
     uint32_t block[BLOCK_INTS];
-    buffer_to_block(buffer, block);
+    buffer_to_block(m_buffer, block);
 
     if (orig_size > BLOCK_BYTES - 8)
     {
-        transform(digest, block, transforms);
+        transform(m_digest, block, transforms);
         for (size_t i = 0; i < BLOCK_INTS - 2; i++)
         {
             block[i] = 0;
@@ -305,18 +319,18 @@ inline std::string SHA1::final()
     /* 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);
+    transform(m_digest, block, transforms);
 
     /* Hex std::string */
     std::ostringstream result;
-    for (size_t i = 0; i < sizeof(digest) / sizeof(digest[0]); i++)
+    for (size_t i = 0; i < sizeof(m_digest) / sizeof(m_digest[0]); i++)
     {
         result << std::hex << std::setfill('0') << std::setw(8);
-        result << digest[i];
+        result << m_digest[i];
     }
 
     /* Reset for next run */
-    reset(digest, buffer, transforms);
+    reset(m_digest, m_buffer, transforms);
 
     return result.str();
 }

From db860653dadbde9e65d69d6ad1457178d747049d Mon Sep 17 00:00:00 2001
From: volatilflerovium <easytable@yandex.com>
Date: Sat, 6 Dec 2025 09:19:17 +0000
Subject: [PATCH 3/6] Add SHA1::m_dataBlock Remove parameter uint32_t block
 from SHA1::blk, SHA1::R0, SHA1::R1, SHA1::R2, SHA1::R3, SHA1::R4 Remove
 parameters from SHA1::transform and SHA1::buffer_to_block, SHA1::reset

---
 sha1.hpp | 244 +++++++++++++++++++++++++++----------------------------
 1 file changed, 122 insertions(+), 122 deletions(-)

diff --git a/sha1.hpp b/sha1.hpp
index 1e4b5bb..c93112e 100644
--- a/sha1.hpp
+++ b/sha1.hpp
@@ -47,25 +47,25 @@ class SHA1
     static const size_t BLOCK_INTS = 16;  /* number of 32bit integers per SHA1 block */
     static const size_t BLOCK_BYTES = BLOCK_INTS * 4;
 
+     uint32_t m_dataBlock[BLOCK_INTS];
     uint32_t m_digest[5];
     std::string m_buffer;
     uint64_t transforms;
 
-    void reset(uint32_t m_digest[], std::string &m_buffer, uint64_t &transforms);
+    void reset();
     uint32_t rol(const uint32_t value, const size_t bits);
-    uint32_t blk(const uint32_t block[BLOCK_INTS], const size_t i);
-    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);
-    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);
-    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);
-    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);
-    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);
-    void transform(uint32_t m_digest[], uint32_t block[BLOCK_INTS], uint64_t &transforms);
-    void buffer_to_block(const std::string &m_buffer, uint32_t block[BLOCK_INTS]);
+    uint32_t blk(const size_t i);
+    void R0(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i);
+    void R1(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i);
+    void R2(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i);
+    void R3(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i);
+    void R4(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i);
+    void transform();
+    void buffer_to_block();
 };
 
 
-
-inline void SHA1::reset(uint32_t m_digest[], std::string &m_buffer, uint64_t &transforms)
+inline void SHA1::reset()
 {
     /* SHA1 initialization constants */
     m_digest[0] = 0x67452301;
@@ -86,9 +86,9 @@ inline uint32_t SHA1::rol(const uint32_t value, const size_t bits)
 }
 
 
-inline uint32_t SHA1::blk(const uint32_t block[BLOCK_INTS], const size_t i)
+inline uint32_t SHA1::blk(const size_t i)
 {
-    return rol(block[(i+13)&15] ^ block[(i+8)&15] ^ block[(i+2)&15] ^ block[i], 1);
+    return rol(m_dataBlock[(i+13)&15] ^ m_dataBlock[(i+8)&15] ^ m_dataBlock[(i+2)&15] ^ m_dataBlock[i], 1);
 }
 
 
@@ -96,41 +96,41 @@ inline uint32_t SHA1::blk(const uint32_t block[BLOCK_INTS], const size_t i)
  * (R0+R1), R2, R3, R4 are the different operations used in SHA1
  */
 
-inline void SHA1::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)
+inline void SHA1::R0(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);
+    z += ((w&(x^y))^y) + m_dataBlock[i] + 0x5a827999 + rol(v, 5);
     w = rol(w, 30);
 }
 
 
-inline void SHA1::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)
+inline void SHA1::R1(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);
+    m_dataBlock[i] = blk(i);
+    z += ((w&(x^y))^y) + m_dataBlock[i] + 0x5a827999 + rol(v, 5);
     w = rol(w, 30);
 }
 
 
-inline void SHA1::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)
+inline void SHA1::R2(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);
+    m_dataBlock[i] = blk(i);
+    z += (w^x^y) + m_dataBlock[i] + 0x6ed9eba1 + rol(v, 5);
     w = rol(w, 30);
 }
 
 
-inline void SHA1::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)
+inline void SHA1::R3(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);
+    m_dataBlock[i] = blk(i);
+    z += (((w|x)&y)|(w&x)) + m_dataBlock[i] + 0x8f1bbcdc + rol(v, 5);
     w = rol(w, 30);
 }
 
 
-inline void SHA1::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)
+inline void SHA1::R4(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);
+    m_dataBlock[i] = blk(i);
+    z += (w^x^y) + m_dataBlock[i] + 0xca62c1d6 + rol(v, 5);
     w = rol(w, 30);
 }
 
@@ -139,7 +139,7 @@ inline void SHA1::R4(uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w,
  * Hash a single 512-bit block. This is the core of the algorithm.
  */
 
-inline void SHA1::transform(uint32_t m_digest[], uint32_t block[BLOCK_INTS], uint64_t &transforms)
+inline void SHA1::transform()
 {
     /* Copy m_digest[] to working vars */
     uint32_t a = m_digest[0];
@@ -149,86 +149,86 @@ inline void SHA1::transform(uint32_t m_digest[], uint32_t block[BLOCK_INTS], uin
     uint32_t e = m_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);
+    R0(a, b, c, d, e,  0);
+    R0(e, a, b, c, d,  1);
+    R0(d, e, a, b, c,  2);
+    R0(c, d, e, a, b,  3);
+    R0(b, c, d, e, a,  4);
+    R0(a, b, c, d, e,  5);
+    R0(e, a, b, c, d,  6);
+    R0(d, e, a, b, c,  7);
+    R0(c, d, e, a, b,  8);
+    R0(b, c, d, e, a,  9);
+    R0(a, b, c, d, e, 10);
+    R0(e, a, b, c, d, 11);
+    R0(d, e, a, b, c, 12);
+    R0(c, d, e, a, b, 13);
+    R0(b, c, d, e, a, 14);
+    R0(a, b, c, d, e, 15);
+    R1(e, a, b, c, d,  0);
+    R1(d, e, a, b, c,  1);
+    R1(c, d, e, a, b,  2);
+    R1(b, c, d, e, a,  3);
+    R2(a, b, c, d, e,  4);
+    R2(e, a, b, c, d,  5);
+    R2(d, e, a, b, c,  6);
+    R2(c, d, e, a, b,  7);
+    R2(b, c, d, e, a,  8);
+    R2(a, b, c, d, e,  9);
+    R2(e, a, b, c, d, 10);
+    R2(d, e, a, b, c, 11);
+    R2(c, d, e, a, b, 12);
+    R2(b, c, d, e, a, 13);
+    R2(a, b, c, d, e, 14);
+    R2(e, a, b, c, d, 15);
+    R2(d, e, a, b, c,  0);
+    R2(c, d, e, a, b,  1);
+    R2(b, c, d, e, a,  2);
+    R2(a, b, c, d, e,  3);
+    R2(e, a, b, c, d,  4);
+    R2(d, e, a, b, c,  5);
+    R2(c, d, e, a, b,  6);
+    R2(b, c, d, e, a,  7);
+    R3(a, b, c, d, e,  8);
+    R3(e, a, b, c, d,  9);
+    R3(d, e, a, b, c, 10);
+    R3(c, d, e, a, b, 11);
+    R3(b, c, d, e, a, 12);
+    R3(a, b, c, d, e, 13);
+    R3(e, a, b, c, d, 14);
+    R3(d, e, a, b, c, 15);
+    R3(c, d, e, a, b,  0);
+    R3(b, c, d, e, a,  1);
+    R3(a, b, c, d, e,  2);
+    R3(e, a, b, c, d,  3);
+    R3(d, e, a, b, c,  4);
+    R3(c, d, e, a, b,  5);
+    R3(b, c, d, e, a,  6);
+    R3(a, b, c, d, e,  7);
+    R3(e, a, b, c, d,  8);
+    R3(d, e, a, b, c,  9);
+    R3(c, d, e, a, b, 10);
+    R3(b, c, d, e, a, 11);
+    R4(a, b, c, d, e, 12);
+    R4(e, a, b, c, d, 13);
+    R4(d, e, a, b, c, 14);
+    R4(c, d, e, a, b, 15);
+    R4(b, c, d, e, a,  0);
+    R4(a, b, c, d, e,  1);
+    R4(e, a, b, c, d,  2);
+    R4(d, e, a, b, c,  3);
+    R4(c, d, e, a, b,  4);
+    R4(b, c, d, e, a,  5);
+    R4(a, b, c, d, e,  6);
+    R4(e, a, b, c, d,  7);
+    R4(d, e, a, b, c,  8);
+    R4(c, d, e, a, b,  9);
+    R4(b, c, d, e, a, 10);
+    R4(a, b, c, d, e, 11);
+    R4(e, a, b, c, d, 12);
+    R4(d, e, a, b, c, 13);
+    R4(c, d, e, a, b, 14);
+    R4(b, c, d, e, a, 15);
 
     /* Add the working vars back into m_digest[] */
     m_digest[0] += a;
@@ -242,12 +242,12 @@ inline void SHA1::transform(uint32_t m_digest[], uint32_t block[BLOCK_INTS], uin
 }
 
 
-inline void SHA1::buffer_to_block(const std::string &m_buffer, uint32_t block[BLOCK_INTS])
+inline void SHA1::buffer_to_block()
 {
     /* Convert the std::string (byte m_buffer) to a uint32_t array (MSB) */
     for (size_t i = 0; i < BLOCK_INTS; i++)
     {
-        block[i] = (m_buffer[4*i+3] & 0xff)
+        m_dataBlock[i] = (m_buffer[4*i+3] & 0xff)
                    | (m_buffer[4*i+2] & 0xff)<<8
                    | (m_buffer[4*i+1] & 0xff)<<16
                    | (m_buffer[4*i+0] & 0xff)<<24;
@@ -257,7 +257,7 @@ inline void SHA1::buffer_to_block(const std::string &m_buffer, uint32_t block[BL
 
 inline SHA1::SHA1()
 {
-    reset(m_digest, m_buffer, transforms);
+    reset();
 }
 
 
@@ -279,9 +279,9 @@ inline void SHA1::update(std::istream &is)
         {
             return;
         }
-        uint32_t block[BLOCK_INTS];
-        buffer_to_block(m_buffer, block);
-        transform(m_digest, block, transforms);
+        //uint32_t m_dataBlock[BLOCK_INTS];
+        buffer_to_block();
+        transform();
         m_buffer.clear();
     }
 }
@@ -304,22 +304,22 @@ inline std::string SHA1::final()
         m_buffer += (char)0x00;
     }
 
-    uint32_t block[BLOCK_INTS];
-    buffer_to_block(m_buffer, block);
+    //uint32_t m_dataBlock[BLOCK_INTS];
+    buffer_to_block();
 
     if (orig_size > BLOCK_BYTES - 8)
     {
-        transform(m_digest, block, transforms);
+        transform();
         for (size_t i = 0; i < BLOCK_INTS - 2; i++)
         {
-            block[i] = 0;
+            m_dataBlock[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(m_digest, block, transforms);
+    m_dataBlock[BLOCK_INTS - 1] = (uint32_t)total_bits;
+    m_dataBlock[BLOCK_INTS - 2] = (uint32_t)(total_bits >> 32);
+    transform();
 
     /* Hex std::string */
     std::ostringstream result;
@@ -330,7 +330,7 @@ inline std::string SHA1::final()
     }
 
     /* Reset for next run */
-    reset(m_digest, m_buffer, transforms);
+    reset();
 
     return result.str();
 }

From b15118e7734195da22040dded8b94fca750e151c Mon Sep 17 00:00:00 2001
From: volatilflerovium <easytable@yandex.com>
Date: Sat, 6 Dec 2025 10:42:43 +0000
Subject: [PATCH 4/6] Set methods SHA1::rol, SHA1::R0, SHA1::R1, SHA1::R2,
 SHA1::R3, SHA1::R4 as template

---
 sha1.hpp | 283 ++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 165 insertions(+), 118 deletions(-)

diff --git a/sha1.hpp b/sha1.hpp
index c93112e..07c7822 100644
--- a/sha1.hpp
+++ b/sha1.hpp
@@ -37,29 +37,75 @@ class SHA1
 {
 public:
     SHA1();
+     /**
+     * Partially calculate the sha1sum of its argument. The calculation
+     * is completed by calling final(). Consecutive calls to update()
+     * will have the effect of calculating the sha1 sum of the concatenated
+     * string of its arguments. For example:
+     * SHA1 sha1;
+     * sha1.update(str1);
+     * sha1.update(str2);
+     * sha1.update(str3);
+     * sha1.final();
+     * is the same than
+     * sha1.update(str1 + str2 + str3);
+     * sha1.final();
+     *
+     * @param cstr null terminated string
+     *
+     * */
     void update(const std::string &s);
-    void update(std::istream &is);
+     void update(std::istream &is);
+
+     /**
+     * Complete the calculation of the sha1sum initiated by calls to
+     * SHA1::update.
+     *
+     * @return return the sha1sum of the string (or strings)
+     *         fed by calls to SHA1::update.
+     * */
     std::string final();
-    static std::string from_file(const std::string &filename);
 
-private:    
+     /**
+     * Get the sha1sum of a file/
+     *
+     * @return return the sha1sum of the content of the specified file.
+     * 
+     * */
+    static std::string from_file(const std::string &filename);
 
+private:
     static const size_t BLOCK_INTS = 16;  /* number of 32bit integers per SHA1 block */
     static const size_t BLOCK_BYTES = BLOCK_INTS * 4;
 
-     uint32_t m_dataBlock[BLOCK_INTS];
+    uint32_t m_dataBlock[BLOCK_INTS];
     uint32_t m_digest[5];
     std::string m_buffer;
     uint64_t transforms;
 
     void reset();
-    uint32_t rol(const uint32_t value, const size_t bits);
-    uint32_t blk(const size_t i);
-    void R0(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i);
-    void R1(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i);
-    void R2(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i);
-    void R3(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i);
-    void R4(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i);
+    template<int N, int M>
+    uint32_t rol(uint32_t value);
+
+    void blk(const size_t i);
+    /*
+    * R0, R1, R2, R3, R4 are the different operations used in SHA1
+    */
+    template<int v, int w, int x, int y, int z>
+    void R0(const size_t i);
+
+    template<int v, int w, int x, int y, int z>
+    void R1(const size_t i);
+
+    template<int v, int w, int x, int y, int z>
+    void R2(const size_t i);
+
+    template<int v, int w, int x, int y, int z>
+    void R3(const size_t i);
+
+    template<int v, int w, int x, int y, int z>
+    void R4(const size_t i);
+
     void transform();
     void buffer_to_block();
 };
@@ -80,15 +126,16 @@ inline void SHA1::reset()
 }
 
 
-inline uint32_t SHA1::rol(const uint32_t value, const size_t bits)
+template<int N, int M>
+inline uint32_t SHA1::rol(uint32_t value)
 {
-    return (value << bits) | (value >> (32 - bits));
+    return (value << N) | (value >> M);
 }
 
 
-inline uint32_t SHA1::blk(const size_t i)
+inline void SHA1::blk(const size_t i)
 {
-    return rol(m_dataBlock[(i+13)&15] ^ m_dataBlock[(i+8)&15] ^ m_dataBlock[(i+2)&15] ^ m_dataBlock[i], 1);
+     m_dataBlock[i]=rol<1, 31>(m_dataBlock[(i+13)&15] ^ m_dataBlock[(i+8)&15] ^ m_dataBlock[(i+2)&15] ^ m_dataBlock[i]);
 }
 
 
@@ -96,42 +143,42 @@ inline uint32_t SHA1::blk(const size_t i)
  * (R0+R1), R2, R3, R4 are the different operations used in SHA1
  */
 
-inline void SHA1::R0(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i)
+template<int v, int w, int x, int y, int z>
+inline void SHA1::R0(const size_t i)
 {
-    z += ((w&(x^y))^y) + m_dataBlock[i] + 0x5a827999 + rol(v, 5);
-    w = rol(w, 30);
+    m_digest[z] =m_digest[z]+ ((m_digest[w]&(m_digest[x]^m_digest[y]))^m_digest[y]) + m_dataBlock[i] + 0x5a827999 + rol<5, 27>(m_digest[v]);
+    m_digest[w] = rol<30, 2>(m_digest[w]);
 }
 
-
-inline void SHA1::R1(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i)
+template<int v, int w, int x, int y, int z>
+inline void SHA1::R1(const size_t i)
 {
-    m_dataBlock[i] = blk(i);
-    z += ((w&(x^y))^y) + m_dataBlock[i] + 0x5a827999 + rol(v, 5);
-    w = rol(w, 30);
+    blk(i);
+    R0<v,w,x,y,z>(i);
 }
 
-
-inline void SHA1::R2(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i)
+template<int v, int w, int x, int y, int z>
+inline void SHA1::R2(const size_t i)
 {
-    m_dataBlock[i] = blk(i);
-    z += (w^x^y) + m_dataBlock[i] + 0x6ed9eba1 + rol(v, 5);
-    w = rol(w, 30);
+    blk(i);
+    m_digest[z] =m_digest[z]+ (m_digest[w]^m_digest[x]^m_digest[y]) + m_dataBlock[i] + 0x6ed9eba1 + rol<5, 27>(m_digest[v]);
+    m_digest[w] = rol<30, 2>(m_digest[w]);
 }
 
-
-inline void SHA1::R3(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i)
+template<int v, int w, int x, int y, int z>
+inline void SHA1::R3(const size_t i)
 {
-    m_dataBlock[i] = blk(i);
-    z += (((w|x)&y)|(w&x)) + m_dataBlock[i] + 0x8f1bbcdc + rol(v, 5);
-    w = rol(w, 30);
+    blk(i);
+    m_digest[z] =m_digest[z]+ (((m_digest[w]|m_digest[x])&m_digest[y])|(m_digest[w]&m_digest[x])) + m_dataBlock[i] + 0x8f1bbcdc + rol<5, 27>(m_digest[v]);
+    m_digest[w] = rol<30, 2>(m_digest[w]);
 }
 
-
-inline void SHA1::R4(const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i)
+template<int v, int w, int x, int y, int z>
+inline void SHA1::R4(const size_t i)
 {
-    m_dataBlock[i] = blk(i);
-    z += (w^x^y) + m_dataBlock[i] + 0xca62c1d6 + rol(v, 5);
-    w = rol(w, 30);
+    blk(i);
+    m_digest[z] =m_digest[z]+ (m_digest[w]^m_digest[x]^m_digest[y]) + m_dataBlock[i] + 0xca62c1d6 + rol<5, 27>(m_digest[v]);
+    m_digest[w] = rol<30, 2>(m_digest[w]);
 }
 
 
@@ -149,86 +196,86 @@ inline void SHA1::transform()
     uint32_t e = m_digest[4];
 
     /* 4 rounds of 20 operations each. Loop unrolled. */
-    R0(a, b, c, d, e,  0);
-    R0(e, a, b, c, d,  1);
-    R0(d, e, a, b, c,  2);
-    R0(c, d, e, a, b,  3);
-    R0(b, c, d, e, a,  4);
-    R0(a, b, c, d, e,  5);
-    R0(e, a, b, c, d,  6);
-    R0(d, e, a, b, c,  7);
-    R0(c, d, e, a, b,  8);
-    R0(b, c, d, e, a,  9);
-    R0(a, b, c, d, e, 10);
-    R0(e, a, b, c, d, 11);
-    R0(d, e, a, b, c, 12);
-    R0(c, d, e, a, b, 13);
-    R0(b, c, d, e, a, 14);
-    R0(a, b, c, d, e, 15);
-    R1(e, a, b, c, d,  0);
-    R1(d, e, a, b, c,  1);
-    R1(c, d, e, a, b,  2);
-    R1(b, c, d, e, a,  3);
-    R2(a, b, c, d, e,  4);
-    R2(e, a, b, c, d,  5);
-    R2(d, e, a, b, c,  6);
-    R2(c, d, e, a, b,  7);
-    R2(b, c, d, e, a,  8);
-    R2(a, b, c, d, e,  9);
-    R2(e, a, b, c, d, 10);
-    R2(d, e, a, b, c, 11);
-    R2(c, d, e, a, b, 12);
-    R2(b, c, d, e, a, 13);
-    R2(a, b, c, d, e, 14);
-    R2(e, a, b, c, d, 15);
-    R2(d, e, a, b, c,  0);
-    R2(c, d, e, a, b,  1);
-    R2(b, c, d, e, a,  2);
-    R2(a, b, c, d, e,  3);
-    R2(e, a, b, c, d,  4);
-    R2(d, e, a, b, c,  5);
-    R2(c, d, e, a, b,  6);
-    R2(b, c, d, e, a,  7);
-    R3(a, b, c, d, e,  8);
-    R3(e, a, b, c, d,  9);
-    R3(d, e, a, b, c, 10);
-    R3(c, d, e, a, b, 11);
-    R3(b, c, d, e, a, 12);
-    R3(a, b, c, d, e, 13);
-    R3(e, a, b, c, d, 14);
-    R3(d, e, a, b, c, 15);
-    R3(c, d, e, a, b,  0);
-    R3(b, c, d, e, a,  1);
-    R3(a, b, c, d, e,  2);
-    R3(e, a, b, c, d,  3);
-    R3(d, e, a, b, c,  4);
-    R3(c, d, e, a, b,  5);
-    R3(b, c, d, e, a,  6);
-    R3(a, b, c, d, e,  7);
-    R3(e, a, b, c, d,  8);
-    R3(d, e, a, b, c,  9);
-    R3(c, d, e, a, b, 10);
-    R3(b, c, d, e, a, 11);
-    R4(a, b, c, d, e, 12);
-    R4(e, a, b, c, d, 13);
-    R4(d, e, a, b, c, 14);
-    R4(c, d, e, a, b, 15);
-    R4(b, c, d, e, a,  0);
-    R4(a, b, c, d, e,  1);
-    R4(e, a, b, c, d,  2);
-    R4(d, e, a, b, c,  3);
-    R4(c, d, e, a, b,  4);
-    R4(b, c, d, e, a,  5);
-    R4(a, b, c, d, e,  6);
-    R4(e, a, b, c, d,  7);
-    R4(d, e, a, b, c,  8);
-    R4(c, d, e, a, b,  9);
-    R4(b, c, d, e, a, 10);
-    R4(a, b, c, d, e, 11);
-    R4(e, a, b, c, d, 12);
-    R4(d, e, a, b, c, 13);
-    R4(c, d, e, a, b, 14);
-    R4(b, c, d, e, a, 15);
+    R0<0, 1, 2, 3, 4>( 0);
+    R0<4, 0, 1, 2, 3>( 1);
+    R0<3, 4, 0, 1, 2>( 2);
+    R0<2, 3, 4, 0, 1>( 3);
+    R0<1, 2, 3, 4, 0>( 4);
+    R0<0, 1, 2, 3, 4>( 5);
+    R0<4, 0, 1, 2, 3>( 6);
+    R0<3, 4, 0, 1, 2>( 7);
+    R0<2, 3, 4, 0, 1>( 8);
+    R0<1, 2, 3, 4, 0>( 9);
+    R0<0, 1, 2, 3, 4>(10);
+    R0<4, 0, 1, 2, 3>(11);
+    R0<3, 4, 0, 1, 2>(12);
+    R0<2, 3, 4, 0, 1>(13);
+    R0<1, 2, 3, 4, 0>(14);
+    R0<0, 1, 2, 3, 4>(15);
+    R1<4, 0, 1, 2, 3>( 0);
+    R1<3, 4, 0, 1, 2>( 1);
+    R1<2, 3, 4, 0, 1>( 2);
+    R1<1, 2, 3, 4, 0>( 3);
+    R2<0, 1, 2, 3, 4>( 4);
+    R2<4, 0, 1, 2, 3>( 5);
+    R2<3, 4, 0, 1, 2>( 6);
+    R2<2, 3, 4, 0, 1>( 7);
+    R2<1, 2, 3, 4, 0>( 8);
+    R2<0, 1, 2, 3, 4>( 9);
+    R2<4, 0, 1, 2, 3>(10);
+    R2<3, 4, 0, 1, 2>(11);
+    R2<2, 3, 4, 0, 1>(12);
+    R2<1, 2, 3, 4, 0>(13);
+    R2<0, 1, 2, 3, 4>(14);
+    R2<4, 0, 1, 2, 3>(15);
+    R2<3, 4, 0, 1, 2>( 0);
+    R2<2, 3, 4, 0, 1>( 1);
+    R2<1, 2, 3, 4, 0>( 2);
+    R2<0, 1, 2, 3, 4>( 3);
+    R2<4, 0, 1, 2, 3>( 4);
+    R2<3, 4, 0, 1, 2>( 5);
+    R2<2, 3, 4, 0, 1>( 6);
+    R2<1, 2, 3, 4, 0>( 7);
+    R3<0, 1, 2, 3, 4>( 8);
+    R3<4, 0, 1, 2, 3>( 9);
+    R3<3, 4, 0, 1, 2>(10);
+    R3<2, 3, 4, 0, 1>(11);
+    R3<1, 2, 3, 4, 0>(12);
+    R3<0, 1, 2, 3, 4>(13);
+    R3<4, 0, 1, 2, 3>(14);
+    R3<3, 4, 0, 1, 2>(15);
+    R3<2, 3, 4, 0, 1>( 0);
+    R3<1, 2, 3, 4, 0>( 1);
+    R3<0, 1, 2, 3, 4>( 2);
+    R3<4, 0, 1, 2, 3>( 3);
+    R3<3, 4, 0, 1, 2>( 4);
+    R3<2, 3, 4, 0, 1>( 5);
+    R3<1, 2, 3, 4, 0>( 6);
+    R3<0, 1, 2, 3, 4>( 7);
+    R3<4, 0, 1, 2, 3>( 8);
+    R3<3, 4, 0, 1, 2>( 9);
+    R3<2, 3, 4, 0, 1>(10);
+    R3<1, 2, 3, 4, 0>(11);
+    R4<0, 1, 2, 3, 4>(12);
+    R4<4, 0, 1, 2, 3>(13);
+    R4<3, 4, 0, 1, 2>(14);
+    R4<2, 3, 4, 0, 1>(15);
+    R4<1, 2, 3, 4, 0>( 0);
+    R4<0, 1, 2, 3, 4>( 1);
+    R4<4, 0, 1, 2, 3>( 2);
+    R4<3, 4, 0, 1, 2>( 3);
+    R4<2, 3, 4, 0, 1>( 4);
+    R4<1, 2, 3, 4, 0>( 5);
+    R4<0, 1, 2, 3, 4>( 6);
+    R4<4, 0, 1, 2, 3>( 7);
+    R4<3, 4, 0, 1, 2>( 8);
+    R4<2, 3, 4, 0, 1>( 9);
+    R4<1, 2, 3, 4, 0>(10);
+    R4<0, 1, 2, 3, 4>(11);
+    R4<4, 0, 1, 2, 3>(12);
+    R4<3, 4, 0, 1, 2>(13);
+    R4<2, 3, 4, 0, 1>(14);
+    R4<1, 2, 3, 4, 0>(15);
 
     /* Add the working vars back into m_digest[] */
     m_digest[0] += a;

From 66e86b52b26f5a2f670cd2752ea07af5db585f7e Mon Sep 17 00:00:00 2001
From: volatilflerovium <easytable@yandex.com>
Date: Fri, 12 Dec 2025 17:22:30 +0000
Subject: [PATCH 5/6] Optimization

---
 CMakeLists.txt                       |  17 +-
 README.md                            |  21 +-
 performance.txt                      |   8 -
 performance/README.md                |  20 ++
 performance/performance.png          | Bin 0 -> 62522 bytes
 performance/performance_1GB_file.png | Bin 0 -> 48750 bytes
 sha1.hpp                             | 519 ++++++++++++++++++---------
 7 files changed, 396 insertions(+), 189 deletions(-)
 delete mode 100644 performance.txt
 create mode 100644 performance/README.md
 create mode 100644 performance/performance.png
 create mode 100644 performance/performance_1GB_file.png

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9a1e6d1..9fc7c18 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -51,6 +51,21 @@ target_link_libraries(
 
 #---------------------------------------------------------------------
 
+set(TEST demo_sha1)
+
+add_executable(
+	"${TEST}" 
+	demo_sha1.cpp
+)
+
+target_link_libraries(
+	"${TEST}"
+	PRIVATE
+	SHA1_lib
+)
+
+#---------------------------------------------------------------------
+
 # Create a 1GB size file for testing performance
 
 if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
@@ -60,7 +75,7 @@ if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
 		OUTPUT_VARIABLE output
 	)
 
-	add_compile_definitions(TEST_FILE="/tmp/1G_test_file.txt")
+	#add_compile_definitions(TEST_FILE="/tmp/1G_test_file.txt")
 endif()
 
 #---------------------------------------------------------------------
diff --git a/README.md b/README.md
index ea98ec8..c2a1ab8 100644
--- a/README.md
+++ b/README.md
@@ -2,17 +2,24 @@
 
 ## Warning
 
-Do not use SHA-1 unless you have to! 
-[SHA-1 is practically broken](https://en.wikipedia.org/wiki/SHA-1#Birthday-Near-Collision_Attack_%E2%80%93_first_practical_chosen-prefix_attack). Use a hash function from the [SHA-2](https://en.wikipedia.org/wiki/SHA-2) or [SHA-3](https://en.wikipedia.org/wiki/SHA-3) family instead.
+Do not use SHA-1 unless you have to. [SHA-1 is practically broken](https://en.wikipedia.org/wiki/SHA-1#Birthday-Near-Collision_Attack_%E2%80%93_first_practical_chosen-prefix_attack). 
+Use a hash function from the [SHA-2](https://en.wikipedia.org/wiki/SHA-2) or [SHA-3](https://en.wikipedia.org/wiki/SHA-3) family instead.
 
-## How to build tests
+- Despite been proven that SHA-1 has collision attacks, SHA-1 is still extensively used, for example in
+websocket protocol.
 
-Using cmake
+- For security related purposes one should use a combination of at least two hashes. For example in pseudocode:
+   - sha2(sha1(data)) not very good
+   - sha1(data)+sha2(data) better
+   - sha1(data.part1)+sha2(data.part2)+sha3(data) strong (where data=data.part1+data.part2)
+
+
+## To build the tests
 ```
+cd tests
 mkdir build
 cd build
-cmake ..
-make
+cmake .. 
 ```
 
 ## License
@@ -26,4 +33,4 @@ make
 - [Volker Diels-Grabsch](https://njh.eu/) (Translation to simpler C++ Code)
 - [Eugene Hopkinson](https://riot.so/) (Safety improvements)
 - [Zlatko Michailov](http://zlatko.michailov.org) (Header-only library)
-- [Dan Machado](dan-machado@yandex.com) (Refactoring)
+- [Dan Machado](dan-machado@yandex.com) (Optimization)
diff --git a/performance.txt b/performance.txt
deleted file mode 100644
index cac5a0e..0000000
--- a/performance.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-perf stat ./../bin/test_sha1
-0.011223803 seconds time elapsed
-
-perf stat ./../bin/test_sha1 --slow
-6.446021922 seconds time elapsed
-
-perf stat ./../bin/test_sha1 /tmp/1G_test_file.txt
-1.885112058 seconds time elapsed
diff --git a/performance/README.md b/performance/README.md
new file mode 100644
index 0000000..f45d77c
--- /dev/null
+++ b/performance/README.md
@@ -0,0 +1,20 @@
+# Profiling
+
+Charts were generated using (time_profiler_visualizer)[https://github.com/volatilflerovium/time_profiler_visualizer]
+
+## Performance
+
+Performace tests run under Debian 11 with AMD Ryzen7 processor.
+
+For a file of 1GB
+   - SHA1 previous version: ~1870ms
+   - Linux command sha1sum: ~1471ms
+   - SHA1 optimized: ~1340ms (under Linux with mmap) and ~1530ms (for Linux and Windows using std::fread)
+
+On a 1 GB file (in seconds)
+
+[![performance-1GB-file.png](https://i.postimg.cc/GpPT4tPZ/performance-1GB-file.png)](https://postimg.cc/7C6ZcxWV)
+
+On incremental string (in microseconds)
+
+[![performance.png](https://i.postimg.cc/J4dN8sK0/performance.png)](https://postimg.cc/YhYGfq5B)
diff --git a/performance/performance.png b/performance/performance.png
new file mode 100644
index 0000000000000000000000000000000000000000..12296fb0bdb7fea4f50f057b3f5e7906e02b102a
GIT binary patch
literal 62522
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

literal 0
HcmV?d00001

diff --git a/performance/performance_1GB_file.png b/performance/performance_1GB_file.png
new file mode 100644
index 0000000000000000000000000000000000000000..460c0366de7238a2c20e953028bc7eaff90bb153
GIT binary patch
literal 48750
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%0AhQ`^g(^i`T7q1RC*ti{)CH
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

literal 0
HcmV?d00001

diff --git a/sha1.hpp b/sha1.hpp
index 07c7822..e3354ca 100644
--- a/sha1.hpp
+++ b/sha1.hpp
@@ -17,112 +17,173 @@
         -- Eugene Hopkinson <slowriot at voxelstorm dot com>
     Header-only library
         -- Zlatko Michailov <zlatko@michailov.org>
-    C++ refactoring
+    C++ optimization
         -- Dan Machado <dan-machado@yandex.com>
 */
 
 #ifndef SHA1_HPP
 #define SHA1_HPP
 
-
-#include <cstdint>
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <sstream>
 #include <string>
+#include <cstring>
+
+#ifdef _LINUX
+    #if __has_include(<sys/mman.h>)
+        // for mmap:
+        #define MMAN_HEADER
+
+        #include <sys/mman.h>
+        #include <sys/stat.h> 
+        #include <fcntl.h>
+    #endif
 
+    #include <unistd.h>
+#else
+    #include <cstdio>
+#endif
+
+//====================================================================
 
 class SHA1
 {
-public:
-    SHA1();
-     /**
-     * Partially calculate the sha1sum of its argument. The calculation
-     * is completed by calling final(). Consecutive calls to update()
-     * will have the effect of calculating the sha1 sum of the concatenated
-     * string of its arguments. For example:
-     * SHA1 sha1;
-     * sha1.update(str1);
-     * sha1.update(str2);
-     * sha1.update(str3);
-     * sha1.final();
-     * is the same than
-     * sha1.update(str1 + str2 + str3);
-     * sha1.final();
-     *
-     * @param cstr null terminated string
-     *
-     * */
-    void update(const std::string &s);
-     void update(std::istream &is);
-
-     /**
-     * Complete the calculation of the sha1sum initiated by calls to
-     * SHA1::update.
-     *
-     * @return return the sha1sum of the string (or strings)
-     *         fed by calls to SHA1::update.
-     * */
-    std::string final();
-
-     /**
-     * Get the sha1sum of a file/
-     *
-     * @return return the sha1sum of the content of the specified file.
-     * 
-     * */
-    static std::string from_file(const std::string &filename);
-
-private:
-    static const size_t BLOCK_INTS = 16;  /* number of 32bit integers per SHA1 block */
-    static const size_t BLOCK_BYTES = BLOCK_INTS * 4;
-
-    uint32_t m_dataBlock[BLOCK_INTS];
-    uint32_t m_digest[5];
-    std::string m_buffer;
-    uint64_t transforms;
-
-    void reset();
-    template<int N, int M>
-    uint32_t rol(uint32_t value);
-
-    void blk(const size_t i);
-    /*
-    * R0, R1, R2, R3, R4 are the different operations used in SHA1
-    */
-    template<int v, int w, int x, int y, int z>
-    void R0(const size_t i);
-
-    template<int v, int w, int x, int y, int z>
-    void R1(const size_t i);
-
-    template<int v, int w, int x, int y, int z>
-    void R2(const size_t i);
-
-    template<int v, int w, int x, int y, int z>
-    void R3(const size_t i);
-
-    template<int v, int w, int x, int y, int z>
-    void R4(const size_t i);
-
-    void transform();
-    void buffer_to_block();
+    public:
+        SHA1();
+
+        /**
+         * Partially calculate the sha1sum of its argument. The calculation
+         * is completed by calling final(). Consecutive calls to update()
+         * will have the effect of calculating the sha1 sum of the concatenated
+         * string of its arguments. For example:
+         * SHA1 sha1;
+         * sha1.update(str1);
+         * sha1.update(str2);
+         * sha1.update(str3);
+         * sha1.final();
+         * is the same than
+         * sha1.update(str1 + str2 + str3);
+         * sha1.final();
+         * which is the same as (using the function operator)
+         * sha1(str1 + str2 + str3)
+         *
+         * @param cstr null terminated string
+         *
+         * */
+        void update(const char* cstr);
+        void update(const std::string& str);
+        void update(const std::string&& str);
+
+        /**
+         * Complete the calculation of the sha1sum initiated by calls to
+         * SHA1::update.
+         *
+         * @return return the sha1sum of the string (or strings)
+         *         fed by calls to SHA1::update.
+         * */
+        std::string final();
+
+        static std::string from_file(const std::string&);
+
+        /**
+         * Function call operator to calculate the sha1sum of
+         * a string. Return the sha1sum of the given string
+         *
+         * @param str a null terminated string or a std::string.
+         * 
+         * @return sha1 sum of the str.
+         *
+         * */
+        std::string operator()(const char* str);
+        std::string operator()(const std::string& str);
+
+        /**
+         * Function call operator to calculate the sha1sum of a file.
+         * It returns false if an error occurs while opening the file and
+         * set the paramenter hashSum as the empty string, otherwise it return
+         * true and it sets the sha1sum of the file in the paramenter hashSum.
+         *
+         * @param fileName the name of a valid file
+         * 
+         *    @param[out] hashSum reference to a std::string where to copy the hashsum
+         *        of the file. If a error occurred, it is set as the empty string
+         * 
+         * @return true if the sha1sum was calculated, false if an error occurs
+         *         while opening the file.
+         * */
+        bool operator()(const char* fileName, std::string& hashSum);
+        bool operator()(const std::string& fileName, std::string& hashSum);
+
+        /**
+         *    Retrieve the description of the error that occurred when trying
+         * to get the sha1sum of a file.
+         *
+         * */
+        std::string getError();
+
+    private:
+        static const size_t BLOCK_INTS = 16;  /* number of 32bit integers per SHA1 block */
+        static const size_t BLOCK_BYTES = BLOCK_INTS * 4;
+        static const size_t DIGEST_SIZE = 5;
+
+        uint32_t m_dataBlock[BLOCK_INTS];
+        uint8_t m_buffer[BLOCK_BYTES];
+        uint32_t m_digestB[DIGEST_SIZE];
+        uint32_t m_digest[DIGEST_SIZE];
+        uint64_t m_transforms;
+        size_t m_dataSize;
+        int m_lastError;
+        const uint8_t* m_bufferPtr;
+
+        void reset();
+
+        template<int N, int M>
+        uint32_t rol(uint32_t value);
+
+        void blk(size_t i);
+
+        /*
+        * R0, R1, R2, R3, R4 are the different operations used in SHA1
+        */
+        template<int v, int w, int x, int y, int z>
+        void R0(const size_t i);
+
+        template<int v, int w, int x, int y, int z>
+        void R1(const size_t i);
+
+        template<int v, int w, int x, int y, int z>
+        void R2(const size_t i);
+
+        template<int v, int w, int x, int y, int z>
+        void R3(const size_t i);
+
+        template<int v, int w, int x, int y, int z>
+        void R4(const size_t i);
+
+        void computeHash(const char* dataPtr, const size_t dataSize);
+
+        std::string fileSha1Sum(const char* fileName);
+
+        /*
+        * Hash a single 512-bit block. This is the core of the algorithm.
+        */
+        void transform();
+        void buffer_to_block();
 };
 
+//====================================================================
 
 inline void SHA1::reset()
 {
     /* SHA1 initialization constants */
-    m_digest[0] = 0x67452301;
-    m_digest[1] = 0xefcdab89;
-    m_digest[2] = 0x98badcfe;
-    m_digest[3] = 0x10325476;
-    m_digest[4] = 0xc3d2e1f0;
+    m_digestB[0] = 0x67452301;
+    m_digestB[1] = 0xefcdab89;
+    m_digestB[2] = 0x98badcfe;
+    m_digestB[3] = 0x10325476;
+    m_digestB[4] = 0xc3d2e1f0;
 
     /* Reset counters */
-    m_buffer = "";
-    transforms = 0;
+    m_transforms = 0;
+    m_dataSize=0;
+    m_bufferPtr=m_buffer;
 }
 
 
@@ -132,17 +193,11 @@ inline uint32_t SHA1::rol(uint32_t value)
     return (value << N) | (value >> M);
 }
 
-
-inline void SHA1::blk(const size_t i)
+inline void SHA1::blk(size_t i)
 {
      m_dataBlock[i]=rol<1, 31>(m_dataBlock[(i+13)&15] ^ m_dataBlock[(i+8)&15] ^ m_dataBlock[(i+2)&15] ^ m_dataBlock[i]);
 }
 
-
-/*
- * (R0+R1), R2, R3, R4 are the different operations used in SHA1
- */
-
 template<int v, int w, int x, int y, int z>
 inline void SHA1::R0(const size_t i)
 {
@@ -182,18 +237,9 @@ inline void SHA1::R4(const size_t i)
 }
 
 
-/*
- * Hash a single 512-bit block. This is the core of the algorithm.
- */
-
 inline void SHA1::transform()
 {
-    /* Copy m_digest[] to working vars */
-    uint32_t a = m_digest[0];
-    uint32_t b = m_digest[1];
-    uint32_t c = m_digest[2];
-    uint32_t d = m_digest[3];
-    uint32_t e = m_digest[4];
+    std::memcpy(m_digest, m_digestB, DIGEST_SIZE*sizeof(uint32_t));
 
     /* 4 rounds of 20 operations each. Loop unrolled. */
     R0<0, 1, 2, 3, 4>( 0);
@@ -277,119 +323,246 @@ inline void SHA1::transform()
     R4<2, 3, 4, 0, 1>(14);
     R4<1, 2, 3, 4, 0>(15);
 
-    /* Add the working vars back into m_digest[] */
-    m_digest[0] += a;
-    m_digest[1] += b;
-    m_digest[2] += c;
-    m_digest[3] += d;
-    m_digest[4] += e;
+    /* Add the working vars back into m_digestB[] */
+    m_digestB[0]=m_digestB[0]+m_digest[0];
+    m_digestB[1]=m_digestB[1]+m_digest[1];
+    m_digestB[2]=m_digestB[2]+m_digest[2];
+    m_digestB[3]=m_digestB[3]+m_digest[3];
+    m_digestB[4]=m_digestB[4]+m_digest[4];
 
     /* Count the number of transformations */
-    transforms++;
+    m_transforms++;
 }
 
 
 inline void SHA1::buffer_to_block()
 {
-    /* Convert the std::string (byte m_buffer) to a uint32_t array (MSB) */
-    for (size_t i = 0; i < BLOCK_INTS; i++)
-    {
-        m_dataBlock[i] = (m_buffer[4*i+3] & 0xff)
-                   | (m_buffer[4*i+2] & 0xff)<<8
-                   | (m_buffer[4*i+1] & 0xff)<<16
-                   | (m_buffer[4*i+0] & 0xff)<<24;
-    }
+    m_dataBlock[0] = m_bufferPtr[3] | m_bufferPtr[2]<<8 | m_bufferPtr[1]<<16 | m_bufferPtr[0]<<24;
+    m_dataBlock[1] = m_bufferPtr[7] | m_bufferPtr[6]<<8 | m_bufferPtr[5]<<16 | m_bufferPtr[4]<<24;
+    m_dataBlock[2] = m_bufferPtr[11] | m_bufferPtr[10]<<8 | m_bufferPtr[9]<<16 | m_bufferPtr[8]<<24;
+    m_dataBlock[3] = m_bufferPtr[15] | m_bufferPtr[14]<<8 | m_bufferPtr[13]<<16 | m_bufferPtr[12]<<24;
+    m_dataBlock[4] = m_bufferPtr[19] | m_bufferPtr[18]<<8 | m_bufferPtr[17]<<16 | m_bufferPtr[16]<<24;
+    m_dataBlock[5] = m_bufferPtr[23] | m_bufferPtr[22]<<8 | m_bufferPtr[21]<<16 | m_bufferPtr[20]<<24;
+    m_dataBlock[6] = m_bufferPtr[27] | m_bufferPtr[26]<<8 | m_bufferPtr[25]<<16 | m_bufferPtr[24]<<24;
+    m_dataBlock[7] = m_bufferPtr[31] | m_bufferPtr[30]<<8 | m_bufferPtr[29]<<16 | m_bufferPtr[28]<<24;
+    m_dataBlock[8] = m_bufferPtr[35] | m_bufferPtr[34]<<8 | m_bufferPtr[33]<<16 | m_bufferPtr[32]<<24;
+    m_dataBlock[9] = m_bufferPtr[39] | m_bufferPtr[38]<<8 | m_bufferPtr[37]<<16 | m_bufferPtr[36]<<24;
+    m_dataBlock[10] = m_bufferPtr[43] | m_bufferPtr[42]<<8 | m_bufferPtr[41]<<16 | m_bufferPtr[40]<<24;
+    m_dataBlock[11] = m_bufferPtr[47] | m_bufferPtr[46]<<8 | m_bufferPtr[45]<<16 | m_bufferPtr[44]<<24;
+    m_dataBlock[12] = m_bufferPtr[51] | m_bufferPtr[50]<<8 | m_bufferPtr[49]<<16 | m_bufferPtr[48]<<24;
+    m_dataBlock[13] = m_bufferPtr[55] | m_bufferPtr[54]<<8 | m_bufferPtr[53]<<16 | m_bufferPtr[52]<<24;
+    m_dataBlock[14] = m_bufferPtr[59] | m_bufferPtr[58]<<8 | m_bufferPtr[57]<<16 | m_bufferPtr[56]<<24;
+    m_dataBlock[15] = m_bufferPtr[63] | m_bufferPtr[62]<<8 | m_bufferPtr[61]<<16 | m_bufferPtr[60]<<24;
 }
 
-
 inline SHA1::SHA1()
 {
     reset();
 }
 
-
-inline void SHA1::update(const std::string &s)
+inline void SHA1::update(const char* cstr)
 {
-    std::istringstream is(s);
-    update(is);
+    computeHash(cstr, std::strlen(cstr));
 }
 
-
-inline void SHA1::update(std::istream &is)
+inline void SHA1::update(const std::string& str)
 {
-    while (true)
-    {
-        char sbuf[BLOCK_BYTES];
-        is.read(sbuf, BLOCK_BYTES - m_buffer.size());
-        m_buffer.append(sbuf, (std::size_t)is.gcount());
-        if (m_buffer.size() != BLOCK_BYTES)
-        {
-            return;
-        }
-        //uint32_t m_dataBlock[BLOCK_INTS];
-        buffer_to_block();
-        transform();
-        m_buffer.clear();
-    }
+    computeHash(str.c_str(), str.length());    
 }
 
+inline void SHA1::update(const std::string&& str)
+{
+    computeHash(str.c_str(), str.length());    
+}
 
 /*
- * Add padding and return the message m_digest.
+ * Add padding and return the message m_digestB.
  */
-
 inline std::string SHA1::final()
 {
     /* Total number of hashed bits */
-    uint64_t total_bits = (transforms*BLOCK_BYTES + m_buffer.size()) * 8;
-
-    /* Padding */
-    m_buffer += (char)0x80;
-    size_t orig_size = m_buffer.size();
-    while (m_buffer.size() < BLOCK_BYTES)
-    {
-        m_buffer += (char)0x00;
-    }
+    uint64_t total_bits = (m_transforms*BLOCK_BYTES + m_dataSize) * 8;
 
-    //uint32_t m_dataBlock[BLOCK_INTS];
-    buffer_to_block();
+    if(m_dataSize<BLOCK_BYTES){
+        std::memset(m_buffer+m_dataSize, 0, BLOCK_BYTES-m_dataSize);
+        m_buffer[m_dataSize]=static_cast<char>(0x80);
+        buffer_to_block();
+    }
 
-    if (orig_size > BLOCK_BYTES - 8)
-    {
+    if (m_dataSize+1 > BLOCK_BYTES - 8){
         transform();
-        for (size_t i = 0; i < BLOCK_INTS - 2; i++)
-        {
-            m_dataBlock[i] = 0;
-        }
+        std::memset(m_dataBlock, 0, sizeof(uint32_t)*(BLOCK_INTS - 2));
     }
 
     /* Append total_bits, split this uint64_t into two uint32_t */
-    m_dataBlock[BLOCK_INTS - 1] = (uint32_t)total_bits;
-    m_dataBlock[BLOCK_INTS - 2] = (uint32_t)(total_bits >> 32);
+    m_dataBlock[BLOCK_INTS - 1] = static_cast<uint32_t>(total_bits);
+    m_dataBlock[BLOCK_INTS - 2] = static_cast<uint32_t>(total_bits >> 32);
     transform();
 
     /* Hex std::string */
-    std::ostringstream result;
-    for (size_t i = 0; i < sizeof(m_digest) / sizeof(m_digest[0]); i++)
-    {
-        result << std::hex << std::setfill('0') << std::setw(8);
-        result << m_digest[i];
+    char resultBuffer[41];
+    for(size_t i = 0; i < DIGEST_SIZE; i++){
+        sprintf(resultBuffer+8*i, "%08x", m_digestB[i]);
     }
+    reset();
+    return resultBuffer;
+}
+
+inline std::string SHA1::from_file(const std::string& filename)
+{
+    std::string hash;
+    SHA1 sha1;
+    sha1(filename, hash);
+    return hash;
+}
 
-    /* Reset for next run */
+inline std::string SHA1::operator()(const char* cstr)
+{
     reset();
+    computeHash(cstr, std::strlen(cstr));
+    return final();
+}
 
-    return result.str();
+inline std::string SHA1::operator()(const std::string& str)
+{
+    reset();
+    computeHash(str.c_str(), str.length());
+    return final();
 }
 
 
-inline std::string SHA1::from_file(const std::string &filename)
+inline bool SHA1::operator()(const char* fileName, std::string& hashSum)
+{
+    reset();
+    hashSum=fileSha1Sum(fileName);
+    return m_lastError==0;
+}
+
+inline bool SHA1::operator()(const std::string& fileName, std::string& hashSum)
 {
-    std::ifstream stream(filename.c_str(), std::ios::binary);
-    SHA1 checksum;
-    checksum.update(stream);
-    return checksum.final();
+    return operator()(fileName.c_str(), hashSum);
 }
 
 
+inline std::string SHA1::getError()
+{
+    return std::strerror(m_lastError);
+}
+
+
+inline void SHA1::computeHash(const char* dataPtr, size_t dataSize)
+{
+    size_t idx=0;
+    size_t newDataSize=dataSize;
+    size_t copyB=BLOCK_BYTES-m_dataSize;
+
+    auto update=[&idx, &copyB, &newDataSize, this](){
+        idx=idx+copyB;
+        newDataSize=newDataSize-copyB;
+        m_dataSize=m_dataSize+copyB;
+    };
+
+    while(true){
+        if(copyB>newDataSize){
+            copyB=newDataSize;
+            m_bufferPtr=m_buffer;
+            std::memcpy(m_buffer+m_dataSize, dataPtr+idx, copyB);
+
+            if(m_dataSize!=BLOCK_BYTES){
+                update();
+                break;
+            }
+        }
+        else{//copyB==BLOCK_BYTES
+            m_bufferPtr=reinterpret_cast<const uint8_t*>(dataPtr+idx);
+        }
+        update();
+        buffer_to_block();
+        transform();
+
+        copyB=BLOCK_BYTES;
+        m_dataSize=0;
+    }
+}
+
+#ifdef MMAN_HEADER
+
+inline std::string SHA1::fileSha1Sum(const char* fileName)
+{
+    m_lastError=0;
+
+    if(access(fileName, F_OK)<0){
+        m_lastError=errno;
+        return "";
+    }
+    if(access(fileName, R_OK)<0){
+        m_lastError=errno;
+        return "";
+    }
+
+    int fd= open(fileName, O_RDONLY);
+    struct stat sb;
+    if(fstat(fd, &sb) == -1) {
+        close(fd);
+        m_lastError=errno;
+        return "";
+    }
+
+    if(sb.st_size>0){
+        void* data=mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+        if(data==MAP_FAILED){
+            close(fd);
+            m_lastError=errno;
+            return "";
+        }
+        else{
+            computeHash(static_cast<const char*>(data), sb.st_size);    
+        }
+        munmap(data, sb.st_size);
+    }
+    close(fd);
+    return final();
+}
+
+#else // for Windows or Linux
+
+inline std::string SHA1::fileSha1Sum(const char* fileName)
+{
+    m_lastError=0;
+
+    if(access(fileName, F_OK)<0){
+        m_lastError=errno;
+        return "";
+    }
+
+    if(access(fileName, R_OK)<0){
+        m_lastError=errno;
+        return "";
+    }
+
+    std::FILE* fd = std::fopen(fileName, "r");
+   if(fd==nullptr){
+        m_lastError=errno;
+        return "";
+    }
+
+    const int p=3;
+    char buffer[p*BLOCK_BYTES];
+
+    while(true){
+        auto dataSize = std::fread(buffer, 1, p*BLOCK_BYTES, fd);
+        if(dataSize==0){
+            break;
+        }
+        computeHash(buffer, dataSize);
+    }
+
+    std::fclose(fd);
+    return final();
+}
+
+#endif
+
+//====================================================================
+
 #endif /* SHA1_HPP */

From 49a71d108ca680155218a50627f184833b44b977 Mon Sep 17 00:00:00 2001
From: volatilflerovium <easytable@yandex.com>
Date: Fri, 12 Dec 2025 17:43:26 +0000
Subject: [PATCH 6/6] Add performance test

---
 CMakeLists.txt                | 14 ------
 performance/CMakeLists.txt    | 88 +++++++++++++++++++++++++++++++++++
 performance/big_file_test.cpp | 47 +++++++++++++++++++
 3 files changed, 135 insertions(+), 14 deletions(-)
 create mode 100644 performance/CMakeLists.txt
 create mode 100644 performance/big_file_test.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9fc7c18..52a474f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -65,17 +65,3 @@ target_link_libraries(
 )
 
 #---------------------------------------------------------------------
-
-# Create a 1GB size file for testing performance
-
-if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-	message("Creating a 1GB file of random data in /tmp directory...")
-	execute_process(COMMAND dd if=/dev/urandom of=/tmp/1G_test_file.txt bs=1G count=1 iflag=fullblock
-		ERROR_VARIABLE error
-		OUTPUT_VARIABLE output
-	)
-
-	#add_compile_definitions(TEST_FILE="/tmp/1G_test_file.txt")
-endif()
-
-#---------------------------------------------------------------------
diff --git a/performance/CMakeLists.txt b/performance/CMakeLists.txt
new file mode 100644
index 0000000..e418581
--- /dev/null
+++ b/performance/CMakeLists.txt
@@ -0,0 +1,88 @@
+cmake_minimum_required(VERSION 3.18)
+project("SHA1_tests")
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_FLAGS "-Wall")
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+set(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/bin)
+
+get_filename_component(PARENT_DIR ../ ABSOLUTE)
+
+
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+	add_definitions(-D_WIN32)
+	add_compile_options("/O2")
+else()
+	add_definitions(-D_LINUX)
+   if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+		message(WARNING "Assuming system in Linux")
+	endif()
+	add_compile_options("-O3")
+	add_compile_options("-g")
+endif()
+
+#---------------------------------------------------------------------
+
+include(FetchContent)
+
+FetchContent_Declare(TimeProfiler
+    GIT_REPOSITORY "https://github.com/volatilflerovium/time_profiler_visualizer"
+    GIT_TAG "origin/main"
+)
+
+FetchContent_MakeAvailable(TimeProfiler)
+
+#---------------------------------------------------------------------
+
+add_library(SHA1_lib INTERFACE)
+
+target_include_directories(
+	SHA1_lib
+	INTERFACE
+	"${CMAKE_SOURCE_DIR}/.."
+)
+
+#---------------------------------------------------------------------
+
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+
+	execute_process(COMMAND ls /tmp/1G_sha1_test_file.txt
+		ERROR_VARIABLE error
+		OUTPUT_VARIABLE output
+	)
+	
+	if(NOT ("${error}" STREQUAL ""))
+		message("Creating a 1G file of random data in /tmp directory...")
+		execute_process(COMMAND dd if=/dev/urandom of=/tmp/1G_sha1_test_file.txt bs=1G count=1 iflag=fullblock
+			ERROR_VARIABLE error
+			OUTPUT_VARIABLE output
+		)
+	endif()
+	add_compile_definitions(TEST_FILE="/tmp/1G_sha1_test_file.txt")
+endif()
+
+#---------------------------------------------------------------------
+
+set(TEST "big_file_test")
+
+add_executable(
+	"${TEST}"
+	big_file_test.cpp
+)
+
+target_link_libraries(
+	"${TEST}"
+	PRIVATE
+	TimeProfiler
+	SHA1_lib
+)
+
+target_compile_definitions(
+	"${TEST}"
+	PRIVATE
+	-DENABLE_STOPWATCH
+)
+
+#---------------------------------------------------------------------
diff --git a/performance/big_file_test.cpp b/performance/big_file_test.cpp
new file mode 100644
index 0000000..9967e58
--- /dev/null
+++ b/performance/big_file_test.cpp
@@ -0,0 +1,47 @@
+#include <iostream>
+
+#include "sha1.hpp"
+
+#include "time_profiler/time_profiler.h"
+
+using Profiler=tprofiler::TimeProfiler<std::chrono::seconds>;
+
+//====================================================================
+
+int main()
+{
+	const char* testFile="";
+	#ifndef TEST_FILE
+		std::cout<<TEST_FILE<<" no found.\n";
+		return 0;
+	#else
+		testFile= TEST_FILE;
+	#endif
+
+	Profiler watch("sha1_new_1file", "#5400AA");
+
+	SHA1 sha1;
+
+	std::string hash;
+
+	for(int i=0; i<10; i++){
+		std::cout<<"sha1sum command: ";
+
+		watch.start();
+			system("sha1sum  /tmp/1G_sha1_test_file.txt");
+		watch.takeSample(true);
+
+		std::cout<<"\nSHA1 class: ";
+		watch.start();
+			if(sha1(testFile, hash)){
+				std::cout<<hash<<"\n";
+			}
+			else{
+				std::cout<<"Error: "<<sha1.getError()<<"\n";
+			}
+		watch.takeSample(true);
+		std::cout<<"\n";
+	}
+
+	return 0;
+}