update SHA1

Author: kmyk

benchmark/proofofwork-sha1.c

@@ -6,10 +6,11 @@ extern uint64_t pow_sha1_count;
 int main(int argc, char **argv) {
     uint8_t mask[pow_sha1_digest_length] = { 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     uint8_t target[pow_sha1_digest_length] = { 0xde, 0xad, 0xbe, 0xaf, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-    uint8_t buffer[pow_sha1_block_length];
-    uint64_t size = 15;
-    memcpy(buffer, "libproofofwork:", size);
-    pow_sha1_mine(mask, target, buffer, &size);
+    uint8_t buffer[pow_sha1_block_length] = { 'f', 'l', 'a', 'g', '{', 0, 0, 0, 0, 0, 0, 0, 0, '}' };
+    int32_t indices[pow_indices_length] = { 5,6,7,8,9,10,11,12 };
+    uint64_t size = 14;
+    pow_set_num_threads(0);
+    pow_sha1_mine(mask, target, buffer, size, indices);
     printf("sha1\n");
     printf("deadbeaf\n");
     printf("%s\n", buffer);

bindings/python/tests/main.py

@@ -16,13 +16,13 @@ def test_md5(self):
         self.snippet_random_test(proofofwork.md5, hashlib.md5)
 
     def test_sha1(self):
-        pass# self.snippet_random_test(proofofwork.sha1, hashlib.sha1)
+        self.snippet_random_test(proofofwork.sha1, hashlib.sha1)
 
     def snippet_random_test_full(self, mine, answer):
         for _ in range(3):
             for len_s in range(1, 6):
                 hash = ''.join([ random.choice('0123456789abcdef?') for _ in range(len_s) ])
-                text = bytes(bytearray([ random.choice(bytearray(b'0123456789abcdef?')) for _ in range(20) ] + [ ord('?') ] * 8))
+                text = bytes(bytearray([ random.choice(bytearray(b'0123456789abcdef?')) for _ in range(20) ] + [ ord('?') ] * 4))
                 alphabet = bytes(bytearray([ random.randrange(256) for _ in range(64) ]))
                 result = mine(hash, text=text, alphabet=alphabet)
                 self.assertIsInstance(result, bytes)
@@ -37,7 +37,7 @@ def test_md5_full(self):
         self.snippet_random_test_full(proofofwork.md5, hashlib.md5)
 
     def test_sha1_full(self):
-        pass# self.snippet_random_test_full(proofofwork.sha1, hashlib.sha1)
+        self.snippet_random_test_full(proofofwork.sha1, hashlib.sha1)
 
 
 if __name__ == '__main__':

include/proofofwork.h

@@ -37,6 +37,6 @@ bool pow_md5_mine(uint8_t const *mask, uint8_t const *target, uint8_t *buffer, u
 
 enum { pow_sha1_block_length = 64 };
 enum { pow_sha1_digest_length = 20 };
-bool pow_sha1_mine(uint8_t *mask, uint8_t *target, uint8_t *buffer, uint64_t *size);
+bool pow_sha1_mine(uint8_t const *mask, uint8_t const *target, uint8_t *buffer, uint64_t size, int32_t const *indices);
 
 #endif

src/md5-avx2.c

@@ -32,13 +32,13 @@ bool pow_md5_mine(uint8_t const *mask, uint8_t const *target, uint8_t *buffer, u
     static_assert (__BYTE_ORDER == __LITTLE_ENDIAN, "");
     if (mask    == NULL) return false;
     if (target  == NULL) return false;
-    if (target  == NULL) return false;
-    if (indices == 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 size <= indices[i]) return false;
+        if (indices[i] < -1 or (int64_t)size <= indices[i]) return false;
     }
-    if (size > pow_md5_block_length - 9) return false;
+    if (indices[0] == -1) return false;
+    if (size > pow_sha1_block_length - sizeof(uint64_t) / CHAR_BIT - 1) return false;
 
     // load hash
     const uint32_t mask_a = ((uint32_t *)mask)[0];
@@ -70,7 +70,9 @@ bool pow_md5_mine(uint8_t const *mask, uint8_t const *target, uint8_t *buffer, u
     const int index7 = indices[7];
     static_assert (pow_indices_length == 8, "");
     repeat (i,pow_indices_length) {
-        local[indices[i]] = 0;
+        if (indices[i] != -1) {
+            local[indices[i]] = 0;
+        }
     }
     uint32_t *padded_alphabet = malloc(alphabet_size * sizeof(uint32_t));
     repeat (i,alphabet_size) {
@@ -89,7 +91,7 @@ bool pow_md5_mine(uint8_t const *mask, uint8_t const *target, uint8_t *buffer, u
     repeat (i4, alphabet_size) { if (index4 != -1) local[index4] = alphabet[i4];
     repeat (i3, alphabet_size) { if (index3 != -1) local[index3] = alphabet[i3];
     repeat (i2, alphabet_size) { if (index2 != -1) local[index2] = alphabet[i2];
-        cnt += alphabet_size * alphabet_size;
+        cnt += alphabet_size * (alphabet_size / vector_width * vector_width);
     repeat (i1, alphabet_size) { if (index1 != -1) local[index1] = alphabet[i1];
         __m256i y0  = _mm256_set1_epi32(((uint32_t *)local)[0 ]);
         __m256i y1  = _mm256_set1_epi32(((uint32_t *)local)[1 ]);
@@ -226,7 +228,7 @@ bool pow_md5_mine(uint8_t const *mask, uint8_t const *target, uint8_t *buffer, u
             }
         }
 
-    // break if unnecessary
+    // break
     } if (index1 == -1 or found) break;
     } if (index2 == -1 or found) break;
     } if (index3 == -1 or found) break;