diff options
Diffstat (limited to 'main.go')
| -rw-r--r-- | main.go | 212 |
1 files changed, 179 insertions, 33 deletions
@@ -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; +} ` |