Merge pull request #20 from kmyk/issue/5

#5: add sha256 support

Author: kmyk

CMakeLists.txt

@@ -17,13 +17,19 @@ if (OPENMP_FOUND)
     set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
 endif ()
 
+# check OpenSSL
+find_package(OpenSSL REQUIRED)
+
 include_directories (include)
 set (sources
     src/md5-avx2.c
     src/sha1-avx2.c
+    src/sha256-openssl.c
     src/common.c
 )
 add_library (proofofwork-shared SHARED ${sources})
 add_library (proofofwork-static STATIC ${sources})
 set_target_properties (proofofwork-shared PROPERTIES OUTPUT_NAME proofofwork)
 set_target_properties (proofofwork-static PROPERTIES OUTPUT_NAME proofofwork)
+target_link_libraries(proofofwork-shared ${OPENSSL_LIBRARIES})
+target_link_libraries(proofofwork-static ${OPENSSL_LIBRARIES})

bindings/python/proofofwork/__init__.py

@@ -17,6 +17,7 @@
 library.pow_set_num_threads.argtypes = (ctypes.c_int, )
 library.pow_md5_mine.restype = ctypes.c_bool
 library.pow_sha1_mine.restype = ctypes.c_bool
+library.pow_sha256_mine.restype = ctypes.c_bool
 
 def _call(
         func, hash, text,
@@ -174,3 +175,23 @@ def sha1(hash, text=None, num_threads=None, alphabet=None):
             text_length_limit=sha1_text_length_limit,
             indices_length=8,
             )
+
+SHA256_DIGEST_LENGTH = 32
+SHA256_BLOCK_LENGTH = 64
+sha256_text_length_limit = 44
+def sha256(hash, text=None, num_threads=None, alphabet=None):
+    '''
+    :type hash: str or None
+    :type text: bytes or None
+    :rtype: bytes
+    '''
+    return _call(
+            library.pow_sha256_mine,
+            hash, text,
+            num_threads=num_threads,
+            alphabet=alphabet,
+            digest_length=SHA256_DIGEST_LENGTH,
+            block_length=SHA256_BLOCK_LENGTH,
+            text_length_limit=sha256_text_length_limit,
+            indices_length=8,
+            )

bindings/python/setup.py

@@ -40,7 +40,7 @@ def run(self):
 
 setup(
     name='proofofwork',
-    version='0.0.11',
+    version='0.0.12',
     description='Simple hash-mining library',
     author='Kimiyuki Onaka',
     author_email='[email protected]',

bindings/python/tests/main.py

@@ -18,6 +18,9 @@ def test_md5(self):
     def test_sha1(self):
         self.snippet_random_test(proofofwork.sha1, hashlib.sha1)
 
+    def test_sha256(self):
+        self.snippet_random_test(proofofwork.sha256, hashlib.sha256)
+
     def snippet_random_test_full(self, mine, answer):
         digest_length = len(answer(b'').hexdigest())
         for _ in range(10):
@@ -48,6 +51,9 @@ def test_md5_full(self):
     def test_sha1_full(self):
         self.snippet_random_test_full(proofofwork.sha1, hashlib.sha1)
 
+    def test_sha256_full(self):
+        self.snippet_random_test_full(proofofwork.sha256, hashlib.sha256)
+
     def snippet_hand_test(self, mine, answer):
         s = '012'
         result = mine(s, text=br'\\\?????')
@@ -62,6 +68,9 @@ def test_md5_hand(self):
     def test_sha1_hand(self):
         self.snippet_hand_test(proofofwork.sha1, hashlib.sha1)
 
+    def test_sha256_hand(self):
+        self.snippet_hand_test(proofofwork.sha256, hashlib.sha256)
+
 
 
 if __name__ == '__main__':

include/proofofwork-private.h

@@ -45,5 +45,6 @@ extern size_t alphabet_size;
 // for benchmark
 extern uint64_t pow_md5_count;
 extern uint64_t pow_sha1_count;
+extern uint64_t pow_sha256_count;
 
 #endif

include/proofofwork.h

@@ -29,7 +29,7 @@ enum { pow_md5_digest_length = 16 };
 /**
  * @param [in]     mask       the length must be pow_md5_digest_length.
  * @param [in]     target     the length must be pow_md5_digest_length.
- * @param [in,out] buffer     the length must be pow_md5_digest_length.
+ * @param [in,out] buffer     the length must be at most pow_md5_block_length.
  * @param [in]     size
  * @param [in]     indices    indices of buffer to modify. the length must be pow_indices.
  * @return                    whether a text is found or not.
@@ -40,4 +40,8 @@ enum { pow_sha1_block_length = 64 };
 enum { pow_sha1_digest_length = 20 };
 bool pow_sha1_mine(uint8_t const *mask, uint8_t const *target, uint8_t *buffer, uint64_t size, int32_t const *indices);
 
+enum { pow_sha256_block_length = 64 };
+enum { pow_sha256_digest_length = 32 };
+bool pow_sha256_mine(uint8_t const *mask, uint8_t const *target, uint8_t *buffer, uint64_t size, int32_t const *indices);
+
 #endif

src/md5-avx2.c

@@ -38,7 +38,7 @@ bool pow_md5_mine(uint8_t const *mask, uint8_t const *target, uint8_t *buffer, u
         if (indices[i] < -1 or (int64_t)size <= indices[i]) return false;
     }
     if (indices[0] == -1) return false;
-    if (size > pow_sha1_block_length - sizeof(uint64_t) / CHAR_BIT - 1) return false;
+    if (size > pow_md5_block_length - sizeof(uint64_t) / CHAR_BIT - 1) return false;
 
     // load hash
     const uint32_t mask_a = ((uint32_t *)mask)[0];

src/sha256-openssl.c

@@ -0,0 +1,52 @@
+#define _BSD_SOURCE
+#include <stdint.h>
+#include <iso646.h>
+#include <stdbool.h>
+#include <string.h>
+#include <openssl/sha.h>
+#include "proofofwork-private.h"
+
+uint64_t pow_sha256_count = 0; // for benchmark
+bool pow_sha256_mine(uint8_t const *mask, uint8_t const *target, uint8_t *buffer, uint64_t size, int32_t const *indices) {
+    // check arguments
+    static_assert (__BYTE_ORDER == __LITTLE_ENDIAN, "");
+    if (mask    == NULL) return false;
+    if (target  == NULL) return false;
+    if (buffer  == NULL) return false;
+    if (indices == NULL) return false;
+    for (int i = 0; i < pow_indices_length; ++ i) {
+        if (indices[i] < -1 or (int64_t)size <= indices[i]) return false;
+    }
+    if (indices[0] == -1) return false;
+    if (size > pow_sha256_block_length - sizeof(uint64_t) / CHAR_BIT - 1) return false;
+
+    // search
+    bool found = false;
+    uint64_t cnt = 0;
+    static_assert (pow_indices_length == 8, "");
+    repeat (i7, alphabet_size) { if (indices[7] != -1) buffer[indices[7]] = alphabet[i7];
+    repeat (i6, alphabet_size) { if (indices[6] != -1) buffer[indices[6]] = alphabet[i6];
+    repeat (i5, alphabet_size) { if (indices[5] != -1) buffer[indices[5]] = alphabet[i5];
+    repeat (i4, alphabet_size) { if (indices[4] != -1) buffer[indices[4]] = alphabet[i4];
+    repeat (i3, alphabet_size) { if (indices[3] != -1) buffer[indices[3]] = alphabet[i3];
+    repeat (i2, alphabet_size) { if (indices[2] != -1) buffer[indices[2]] = alphabet[i2];
+    repeat (i1, alphabet_size) { if (indices[1] != -1) buffer[indices[1]] = alphabet[i1];
+    repeat (i0, alphabet_size) { if (indices[0] != -1) buffer[indices[0]] = alphabet[i0];
+        uint8_t digest[pow_sha256_digest_length];
+        SHA256(buffer, size, digest);
+        ++ cnt;
+        found = true;
+        repeat (j, pow_sha256_digest_length) {
+            if ((digest[j] & mask[j]) != (target[j] & mask[j])) {
+                found = false;
+                break;
+            }
+        }
+        if (found) goto done;
+    }}}}}}}}
+done: ;
+
+    // leave
+    pow_sha256_count = cnt;
+    return found;
+}