Use C program instead of Python script to solve the challenge

1 files changed, 179 insertions, 33 deletions

diff --git a/main.go b/main.go
index be95865..fdf75d4 100644
--- a/main.go
+++ b/main.go
@@ -80,8 +80,8 @@ Encode your selected value in base64 and submit it below:
 <br />
 <details>
 <summary>
-Python script to automatically solve this
-</summary><pre>` + html.EscapeString(pythonScript) + `</pre>
+Program to solve this
+</summary><pre>` + html.EscapeString(solverProgram) + `</pre>
 </details>
 </body>
 </html>
@@ -244,35 +244,181 @@ func validateBitZeros(bs []byte, n uint) bool {
 	return true
 }
 
-const pythonScript = `
-import base64
-import hashlib
-import random
-import sys
-
-def proc(encoded, n_bits):
-    decoded = base64.b64decode(encoded)
-    while True:
-        appended = bytes([random.randint(0, 255) for _ in range(16)])
-        sha256_hash = hashlib.sha256(decoded + appended).digest()
-        hash_bits = ''.join(f'{byte:08b}' for byte in sha256_hash)
-        if hash_bits[:n_bits] == '0' * n_bits:
-            return appended
-
-def main() :
-    if len(sys.argv) != 3:
-        print(f"usage: {sys.argv[0]} <encoded> <n_bits>", file=sys.stderr)
-        sys.exit(1)
-    
-    encoded = sys.argv[1]
-    n_bits = int(sys.argv[2])
-    
-    if n_bits < 0 or n_bits > 256:
-        print("error: n_bits should be between 0 and 256", file=sys.stderr)
-        sys.exit(1)
-    
-    print(base64.b64encode(proc(encoded, n_bits)).decode("ascii"))
-
-if __name__ == "__main__":
-    main()
+const solverProgram = `
+#include <openssl/evp.h>
+#include <openssl/bio.h>
+#include <openssl/buffer.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+
+bool validate_bit_zeros(const unsigned char *bs, uint8_t n)
+{
+	uint8_t q = n / 8;
+	uint8_t r = n % 8;
+
+	for (uint8_t i = 0; i < q; i++) {
+		if (bs[i] != 0)
+			return false;
+	}
+
+	if (r > 0) {
+		unsigned char mask = (unsigned char)(0xFF << (8 - r));
+		if (bs[q] & mask)
+			return false;
+	}
+
+	return true;
+}
+
+int main(int argc, char **argv)
+{
+	if (argc < 3) {
+		fprintf(stderr, "usage: %s <base64_data> <difficulty>\n",
+			argv[0]);
+		return 1;
+	}
+
+	size_t base64_data_len = strlen(argv[1]);
+	unsigned char *base64_data = malloc(base64_data_len);
+	if (!base64_data) {
+		perror("malloc");
+		return 1;
+	}
+	memcpy(base64_data, argv[1], base64_data_len);
+
+	char *endptr = NULL;
+	errno = 0;
+	unsigned long tmp_val = strtoul(argv[2], &endptr, 10);
+	if ((errno == ERANGE && tmp_val == ULONG_MAX) || *endptr != '\0'
+	    || tmp_val > UINT8_MAX) {
+		fprintf(stderr, "invalid difficulty value\n");
+		free(base64_data);
+		return 1;
+	}
+	uint8_t difficulty = (uint8_t) tmp_val;
+
+	BIO *b64 = BIO_new(BIO_f_base64());
+	BIO *bmem = BIO_new_mem_buf(base64_data, (int)base64_data_len);
+	if (!b64 || !bmem) {
+		fprintf(stderr, "BIO_new/BIO_new_mem_buf\n");
+		free(base64_data);
+		return 1;
+	}
+
+	BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
+	b64 = BIO_push(b64, bmem);
+
+	size_t decoded_cap = base64_data_len;
+	unsigned char *decoded = malloc(decoded_cap);
+	if (!decoded) {
+		perror("malloc");
+		BIO_free_all(b64);
+		free(base64_data);
+		return 1;
+	}
+
+	int decoded_len = BIO_read(b64, decoded, (int)decoded_cap);
+	if (decoded_len < 0) {
+		fprintf(stderr, "BIO_read\n");
+		BIO_free_all(b64);
+		free(base64_data);
+		free(decoded);
+		return 1;
+	}
+	BIO_free_all(b64);
+	free(base64_data);
+
+	EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
+	if (!mdctx) {
+		fprintf(stderr, "EVP_MD_CTX_new\n");
+		free(decoded);
+		return 1;
+	}
+
+	size_t len = EVP_MD_size(EVP_sha256());
+	unsigned char digest[EVP_MAX_MD_SIZE];
+	size_t next = 0;
+
+	while (1) {
+		if (EVP_DigestInit_ex(mdctx, EVP_sha256(), NULL) != 1) {
+			fprintf(stderr, "EVP_DigestInit_ex\n");
+			EVP_MD_CTX_free(mdctx);
+			free(decoded);
+			return 1;
+		}
+		if (EVP_DigestUpdate(mdctx, decoded, decoded_len) != 1) {
+			fprintf(stderr, "EVP_DigestUpdate(data)\n");
+			EVP_MD_CTX_free(mdctx);
+			free(decoded);
+			return 1;
+		}
+		if (EVP_DigestUpdate(mdctx, &next, sizeof(next)) != 1) {
+			fprintf(stderr, "EVP_DigestUpdate(next)\n");
+			EVP_MD_CTX_free(mdctx);
+			free(decoded);
+			return 1;
+		}
+		if (EVP_DigestFinal_ex(mdctx, digest, NULL) != 1) {
+			fprintf(stderr, "EVP_DigestFinal_ex\n");
+			EVP_MD_CTX_free(mdctx);
+			free(decoded);
+			return 1;
+		}
+		if (validate_bit_zeros(digest, difficulty)) {
+			break;
+		}
+		next++;
+		if (!next) {
+			fprintf(stderr, "unsigned integer overflow\n");
+			EVP_MD_CTX_free(mdctx);
+			free(decoded);
+			return 1;
+		}
+	}
+	EVP_MD_CTX_free(mdctx);
+	free(decoded);
+
+	BIO *b64_out = BIO_new(BIO_f_base64());
+	BIO *bmem_out = BIO_new(BIO_s_mem());
+	if (!b64_out || !bmem_out) {
+		fprintf(stderr, "BIO_new\n");
+		if (b64_out)
+			BIO_free_all(b64_out);
+		if (bmem_out)
+			BIO_free(bmem_out);
+		return 1;
+	}
+	BIO_set_flags(b64_out, BIO_FLAGS_BASE64_NO_NL);
+	b64_out = BIO_push(b64_out, bmem_out);
+
+	if (BIO_write(b64_out, &next, sizeof(next)) < 0) {
+		fprintf(stderr, "BIO_write\n");
+		BIO_free_all(b64_out);
+		return 1;
+	}
+	if (BIO_flush(b64_out) < 1) {
+		fprintf(stderr, "BIO_flush\n");
+		BIO_free_all(b64_out);
+		return 1;
+	}
+
+	BUF_MEM *bptr = NULL;
+	BIO_get_mem_ptr(b64_out, &bptr);
+	if (!bptr || !bptr->data) {
+		fprintf(stderr, "BIO_get_mem_ptr\n");
+		BIO_free_all(b64_out);
+		return 1;
+	}
+
+	write(STDOUT_FILENO, bptr->data, bptr->length);
+	write(STDOUT_FILENO, "\n", 1);
+
+	BIO_free_all(b64_out);
+	return 0;
+}
 `