Криптография в #bitcoin: как создать или сгенерировать адрес Bitcoin на языке C

Криптография в #bitcoin: как создать или сгенерировать адрес Bitcoin на языке C

Криптография с открытым ключом является неотъемлемой частью сети Bitcoin. Далее мы объясним, как можно сгенерировать закрытые и открытые ключи для биткойнов, а также адреса для биткойнов с нуля, используя язык программирования C. Мы также расскажем о некоторых вариантах дизайна и функциях протокола #Bitcoin, которые реализовал Сатоши Накамото.

Криптография с открытым ключом (асимметричная)

Предшественником криптографии с открытым ключом является криптография с симметричным ключом, когда вы и получатель делятся секретным паролем и используем его для шифрования и дешифрования сообщений, которые вы отправляете друг другу.

Например, вы можете заменить букву A на B, B на C и так далее. Чтобы расшифровать ваше секретное сообщение, нужно сделать обратное, используя тот же ключ.

Фундаментальный недостаток этой схемы заключается в том, что мы должны поделиться секретным ключом, чтобы использовать его, но поскольку нам еще предстоит установить безопасное зашифрованное соединение для связи, то злоумышленник может перехватить наш секретный ключ!

Криптография с открытым ключом решает эту проблему. Когда у каждого пользователя есть свой секретный закрытый ключ и открытый ключ . Если я хочу отправить вам сообщение, то я сначала получаю копию вашего открытого ключа, а затем использую его для шифрования своего сообщения. Затем я могу передать это зашифрованное сообщение вам, где вы используете свой закрытый ключ для расшифровки сообщения. Обратите внимание, что вы можете спокойно и открыто делиться своим открытым ключом, а не тайно , и пока никто другой не знает ваш закрытый ключ, сообщение будет защищено от посторонних глаз. Так как с помощью открытого ключа можно только зашифровать сообщение, но не расшифровать его.

Существует множество различных протоколов с открытым ключом и во всех из них вы можете сгенерировать открытый ключ из закрытого ключа, но нельзя это сделать наоборот. Эти протоколы полагаются на специальные криптографические функции, которые работают исключительно в одну сторону, гарантируя невозможность определения закрытого ключа зная открытый ключ и функцию шифрования.

В протоколе Bitcoin адрес — это адрес, на который отправляются монеты #bitcoin. Вы можете сгенерировать адрес, взяв хэш вашего открытого ключа. Криптографическая хеш-функция принимает любые входные данные и возвращает строку фиксированной длины. Причём, невозможно вычислить обратное значение, поскольку эти функции являются однонаправленными. Например, часто используемая хэш-функция SHA-256:

SHA256("Vitalij")
= "98746c3152e93a59706e48567e067bb08ea0afe76d05ac27aa9c1ea52340c8ba"

SHA256("Vitali")
= "a03303ed8f20414dd8eeb501f66e5f61cba9dbdf45f96a0d31de5bf63dde43ae"

Попробовать работу хэш-функции SHA-256 можно на этом сайте:
https://emn178.github.io/online-tools/sha256.html

Обратите внимание, как простое добавление одной буквы во входную строку полностью меняет хэш. Также посмотрите, как хэш-функция выводит строку фиксированной длины независимо от входной длины.

Биткойн-адреса (устаревший формат P2PKH)

В Bitcoin теперь есть несколько типов адресов (см. /wiki/Address ).

Первоначальные "унаследованные" адреса, которые реализовал Сатоши Накамото, начинаются с номера 1:
1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa.

Этот тип адреса известен как Pay-to-PubkeyHash или сокращенно P2PKH.

Вот шаги, необходимые для расчета устаревшего адреса:

1.. Взять число из 64-х цифр в 16-й системе счисления

public_key = 7aec57a3f9b216a40ff7da9ee24064a837bf61b80e50f6e7fc67ea06bf8a7cc9

Можно использовать вот этот онлайн генератор случайных чисел в 16-ричной системе счисления:
https://www.browserling.com/tools/random-hex

2.. Вычислите хэш SHA-256 открытого ключа

SHA256(public_key) = 2f002458f9c50a2a38e7fe29b213af89cccc05ffb6835c9fce19151a03cc9419

3.. Вычислите хэш RIPEMD-160 этого хэша SHA-256

RIPEMD160(SHA256(public_key)) = 719a1c17453fe2fc18da1f46d3c409e04d3e692a

Можно использовать вот этот онлайн калькулятор для вычисления хэш-функции RIPEMD-160:
https://md5calc.com/hash/ripemd160

4.. Добавьте байт версии адреса перед этим хэшем, чтобы завершить наш адрес ( 0x00 для основной сети)

00719a1c17453fe2fc18da1f46d3c409e04d3e692a

5.. Чтобы создать контрольную сумму, два раза берем хэш SHA-256 полученного в пункте 4 расширенного хэша RIPEMD-160 и берем первые 4 байта или 8 символов в 16-ричной системе счисления

SHA256(SHA256(0x00 & RIPEMD160(SHA256(public_key)))) = e97526ff27a104ccdae771c702dc024010a41fd513042294c99a619ff4203e30

e97526ff - наша контрольная сумма

6.. Добавляем контрольную сумму в конец исходного хэша RIPEMD160 на шаге 4.

00719a1c17453fe2fc18da1f46d3c409e04d3e692ae97526ff

7.. Преобразуем результат из шестнадцатеричной системы счисления в base58 строку

1BMfyQhYFdx2YtAfJFDbmTAgNiy6RbzXxA

Можно использовать вот этот онлайн калькулятор для преобразования числа из 16-ричной системы счисления (hex) в base58:
https://appdevtools.com/base58-encoder-decoder

8.. Удалите все лишние начальные единицы.

В base58 "1" представляет собой нулевое значение и, следовательно, не учитывается перед адресом. Однако, первый лидирующий символ "1" включен для первого '00' байта.

В нашем примере ничего не нужно делать, так как наш адрес выше имеет только одну 1, соответствующую единственной 0x00.

1BMfyQhYFdx2YtAfJFDbmTAgNiy6RbzXxA

Это сложная схема!
Но она включает в себя несколько очень полезных функций, которые подробно описаны ниже.

Контрольная сумма

Контрольная сумма позволяет любому подтвердить, что этот публичный адрес является правильным адресом. Если кто-то пришлет нам адрес, то мы можем проверить его правильность, выполнив шаги 5 и 6 для первых 21 байта (42 символа в 16-ричной системе счисления), а затем проверить правильность последних 4 байтов (8 символов в 16-ричной системе счисления) адреса.

Это очень полезно при вводе общедоступного адреса вручную, поскольку большинство кошельков предотвратят попытку отправки биткойнов на неправильный адрес.

База 58

Адрес 1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa в формате Base58 на первый взгляд может показаться странным способом представления адресов, но у него есть некоторые качества, которые делают его лучше по сравнению с десятичным представлением 0-9.
Во-первых, использование системы счисления с большим основанием позволяет более короткое представление больших целых чисел.

Например, число 1228 в двоичном формате будет выглядеть так: 10011001100 в двоичном формате (основание 2, двоичная система счисления), но выглядит как NB в base58 (основание 58, 58-ричная система счисления). Поскольку биткойн-адреса технически представляют собой очень большие целые числа, это значительно упрощает отправку и чтение адресов.

Вы можете потренироваться с этим тут:
https://learnmeabitcoin.com/technical/base58

Человек, склонный к вычислениям, может спросить, а почему бы не использовать что-то более естественное, например, base64?
Итак, base58 использует все числа, строчные и прописные буквы, за исключением символов, которые легко ошибиться (0, O, I, l).
Примечание 2 × 26 + 10 − 4 = 58
Удаление этих сбивающих с толку символов значительно снижает вероятность неправильного ввода биткойн-адресов.

Создание биткойн-адресов в C

Биткойн использует криптографию на основе эллиптических кривых для создания пары открытого и закрытого ключей. Сейчас всё, что нам нужно знать, это то, что #Bitcoin использует эллиптическую кривую, которая называется secp256k1, для создания открытого ключа из закрытого ключа. И эти ключи обладают свойствами асимметричной криптографии, которые описаны ранее.

Чтобы использовать эту эллиптическую кривую в C, мы будем использовать библиотеку bitcoin-core/secp256k1. Установка этой библиотеки в Linux и MacOS довольна проста и тривиальна.

Чтобы использовать эту библиотеку, мы должны настроить sep256k1_context вот так:

#include <secp256k1.h>

static secp256k1_context *ctx = NULL;

ctx = secp256k1_context_create(
            SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);

Из документации библиотеки:

"Цель структур контекста — кэшировать большие предварительно вычисленные таблицы данных, которые дорого создавать…"

Это позволяет быстро генерировать адреса, и нам понадобится контекст для генерации наших ключей.

Генерация закрытого ключа на языке программирования C

Закрытый ключ в bitcoin — это 256-битное число.
Его можно представить как 32 байта.

В шестнадцатеричном виде оно будет содержать 64 символа:
5A7234743777217A25432A462D4A614E645267556B58703273357638782F413F

Вы также можете поэкспериментировать с генерацией случайного 256-битного числа на этом сайте:
https://www.allkeysgenerator.com/Random/Security-Encryption-Key-Generator.aspx

В системах Unix мы можем получить случайное число из /dev/urandom, если вы сделаете вывод /dev/urandom, то вы увидите целую кучу случайных символов.

cat /dev/urandom

Используя язык C, мы можем загрузить 32 случайных байта, прочитав их из /dev/urandom:

#include <stdio.h>

#include "secp256k1-0.3.0/include/secp256k1.h"
#include "secp256k1-0.3.0/include/secp256k1_ecdh.h"

static secp256k1_context *ctx = NULL;

int main() {
    ctx = secp256k1_context_create(
    SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
    
    /* Declare the private variable as a 32 byte unsigned char */
    /* Объявляем приватную переменную размером в 32-байта с типом символ без знака */
    unsigned char seckey[32];

    /* Load private key (seckey) from random bytes */
    /* Загрузим закрытый ключ (seckey) из случайных байтов */
    FILE *finput = fopen("/dev/urandom", "r");

    /* Read 32 bytes from finput */
    /* Читаем 32 байта из finput */
    fread(seckey, 32, 1, finput);

    /* Close the file */
    /* Закрываем этот файл */
    fclose(finput);

    /* Loop through and print each byte of the private key, */
     /* Перебираем в цикле и печатаем каждый байт закрытого ключа, */
    printf("Private Key: ");
    for(int i = 0; i < 32; i++) {
            printf("%02X", seckey[i]);
    }
    printf("\n");
}

Комментарий:
"%x" — это спецификатор формата, который форматирует и выводит шестнадцатеричное значение.
Если вы выводите переменную типа int или long, то оно преобразует его в шестнадцатеричный формат.
"%02x" означает, что если выводимое вами значение меньше двух цифр, то "0" будет добавлен в начале.

Сохраним этот код в файл "privkey.c" и скомпилируем с помощью:

gcc -O2 -lgmp -lcrypto -lsecp256k1 secp256k1-0.3.0/.libs/libsecp256k1.a  privkey.c -o privkey

Далее запустим:

./privkey

Программа выведет:

Private Key: DBC6711A5153E1E3532EDE594C2F4B25863414E35FB23396F8F08535DC851ABC

Из-за ограничений кривой secp256k1 не все закрытые ключи будут действительны.
Есть 1/2¹²⁸ вероятность того, что закрытый ключ недействителен, поэтому нам нужно проверить, действителен ли наш ключ, включив следующий код в нашу программу:

if (!secp256k1_ec_seckey_verify(ctx, seckey)) {
    printf("Invalid secret key\n");
    return 1;
}

// Compile with:
// gcc -O2 -I secp256k1-0.3.0/src/ -I secp256k1-0.3.0/ -lgmp -lcrypto -lsecp256k1  privkey.c

#include <stdio.h>

#include "secp256k1-0.3.0/include/secp256k1.h"
#include "secp256k1-0.3.0/include/secp256k1_ecdh.h"

static secp256k1_context *ctx = NULL;

int main() {
    ctx = secp256k1_context_create(
    SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
    
    /* Declare the private variable as a 32 byte unsigned char */
    /* Объявляем приватную переменную размером в 32-байта с типом символ без знака */
    unsigned char seckey[32];

    /* Load private key (seckey) from random bytes */
    /* Загрузим закрытый ключ (seckey) из случайных байтов */
    FILE *finput = fopen("/dev/urandom", "r");

    /* Read 32 bytes from finput */
    /* Читаем 32 байта из finput */
    fread(seckey, 32, 1, finput);

    /* Close the file */
    /* Закрываем этот файл */
    fclose(finput);

    if (!secp256k1_ec_seckey_verify(ctx, seckey)) {
        printf("Invalid secret key\n");
    return 1;
    }
    
    /* Loop through and print each byte of the private key, */
    /* Перебираем в цикле и печатаем каждый байт закрытого ключа, */
    printf("Private Key: ");
    for(int i = 0; i < 32; i++) {
        printf("%02X", seckey[i]);
    }
    printf("\n");
    
    
    return 0;
}

Создание открытого ключа на языке C

Теперь, когда у нас есть 32-байтовый закрытый ключ, мы можем использовать библиотеку secp256k1 для вычисления соответствующего открытого ключа.

Во-первых, нам нужно объявить новую переменную secp256k1_pubkey для хранения нашего открытого ключа:

secp256k1_pubkey pubkey;

Затем создаем публичный ключ с помощью функции из библиотеки secp256k1:

secp256k1_ec_pubkey_create(ctx, &pubkey, seckey);

Обратите внимание, что эта функция принимает указатель на переменную pubkey, куда должен быть записан открытый ключ.

Теперь нам нужно сериализовать этот адрес, чтобы перевести его в байты. Мы используем переменную size_t для хранения длины адреса в байтах:

size_t pk_len = 65;
char pk_bytes[65];

/* Serialize Public Key */
/* Сериализация открытого ключа */
secp256k1_ec_pubkey_serialize(
    ctx,
    pk_bytes,
    &pk_len,
    &pubkey,
    SECP256K1_EC_UNCOMPRESSED
    );

Эта функция принимает указатель на длину и переменную открытого ключа. Она сериализует открытый ключ в байты, чтобы мы могли затем манипулировать им.

Создание биткойн-адреса на языке программирования C

В настоящее время у нас есть закрытый ключ и соответствующий ему открытый ключ в байтах.

Мы хотим следовать схеме, описанной ранее, для создания биткойн-адреса.
Здесь нам нужно будет использовать библиотеку C openssl (-lcrypto) для обеспечения необходимых функций хеширования SHA256 и RIPEMD160.

В верхней части нашего файла .c мы подключаем файлы этих библиотек:

#include <openssl/sha.h>
#include <openssl/ripemd.h>

Чтобы использовать эти хеш-функции, нам нужны несколько новых переменных:
переменная char длиной 34 байта для хранения нашего адреса,
байтовая переменная rmd длины 5+RIPEMD160_DIGEST_LENGTH (5+20) для хранения наших окончательных хэшей.

Мы также будем использовать переменную байтового типа s для хранения некоторых временных хэшей:

char pubaddress[34];
byte s[65];
byte rmd[5 + RIPEMD160_DIGEST_LENGTH];

Нам нужно определить тип byte в верхней части нашего файла с помощью typedef unsigned char byte.

Во-первых, давайте дублируем наш открытый ключ в переменную s, перебирая каждый байт.

Копируем открытый ключ размером 65 байт:

int j;
for (j = 0; j < 65; j++) {
    s[j] = pk_bytes[j];
}

Следуя схеме, описанной в шагах нашего алгоритма по созданию устаревшего биткойн-адреса.
Мы берем первый хэш SHA256 нашего открытого ключа s в хэш-функции SHA256(s, 65, 0), а затем берем RIPEMD160 этого хэша в функции RIPEMD160(SHA_HASH, SHA256_DIGEST_LENGTH, md), где md — это место, где мы сохраняем выходные данные.

Нам также нужно установить байт версии в начале адреса на 0x00:

/* Set 0x00 byte for main net */
/* Устанавливаем 0x00 байт для основной версии биткоин адреса */
rmd[0] = 0;
RIPEMD160(SHA256(s, 65, 0), SHA256_DIGEST_LENGTH, rmd + 1);

На этом этапе мы реализовали шаги 1-3 нашего алгоритма.
Теперь нам нужно найти контрольную сумму.

Чтобы создать контрольную сумму, мы дважды берем SHA256 полученного на предыдущем шаге хеша:

SHA256(SHA256(rmd, 21, 0), SHA256_DIGEST_LENGTH, 0);

Но нам нужны только последние 4 байта контрольной суммы, поэтому мы можем использовать memcpy для копирования этих байтов в конец первых 21 байта rmd:

memcpy(rmd + 21, SHA256(SHA256(rmd, 21, 0), SHA256_DIGEST_LENGTH, 0), 4);

Чтобы использовать функцию memcpy, нам нужно добавить #include <string.h> вверхней части нашего файла.

Теперь мы очень близки к получению пригодного биткойн-адреса. Осталось только преобразовать эти байты в base58.

Мы можем сами написать и использовать эту функцию base58 для преобразования в base58.

Разместите base58() над нашей функцией main():

/* See https://en.wikipedia.org/wiki/Positional_notation#Base_conversion */
char* base58(byte *s, int s_size, char *out, int out_size) {
        static const char *base_chars = "123456789"
                "ABCDEFGHJKLMNPQRSTUVWXYZ"
                "abcdefghijkmnopqrstuvwxyz";

        byte s_cp[s_size];
        memcpy(s_cp, s, s_size);

        int c, i, n;

        out[n = out_size] = 0;
        while (n--) {
                for (c = i = 0; i < s_size; i++) {
                        c = c * 256 + s_cp[i];
                        s_cp[i] = c / 58;
                        c %= 58;
                }
                out[n] = base_chars[c];
        }

        return out;
}

Чтобы сохранить наш адрес, нам нужна переменная типа char длиной 34 символа.

Теперь мы можем создать наш биткойн-адрес с этими последними строками в функции main:

char address[34];
base58(rmd, 25, address, 34);

В финале, нам нужно удалить все лишние лидирующие единицы в начале адреса.

Мы можем найти количество ведущих 1, которые нам нужно удалить, подсчитав количество 1 в начале адреса и вычтя количество байтов 0x00 в начале нашего хэша rmd.
Если нужно удалить цифру, то мы сдвигаем память, которая хранит адрес, на единицу, удаляя первую цифру.
Мы также укорачиваем строку на количество удаленных единиц.

/* Count the number of extra 1s at the beginning of the address */
/* Подсчитываем количество лишних 1 в начале адреса */
int k;
for (k = 1; address[k] == '1'; k++);

/* Count the number of extra leading 0x00 bytes */
/* Подсчитываем количество лишних начальных байтов 0x00 */
int n;
for (n = 1; rmd[n] == 0x00; n++);

/* Remove k-n leading 1's from the address */
/* Удаляем k-n ведущих единиц из адреса */
memmove(address, address + (k - n), 34 - (k - n));
address[34 - (k - n)] = '\0';

printf("Address: %s\n\n", address);

Когда вы скомпилируете программу с помощью
gcc -O2 -I secp256k1-0.3.0/src/ -I secp256k1-0.3.0/ -lgmp -lcrypto -lsecp256k1 privkey.c -o privkey или gcc privkey.c -o privkey -lcrypto -lsecp256k1
и запустите с ./privkey, то надеюсь, что Вы встретите биткойн-адрес, который начинается с цифры 1:

$ gcc -O2 -lgmp -lcrypto -Wno-deprecated-declarations -lsecp256k1 secp256k1-0.3.0/.libs/libsecp256k1.a  privkey.c -o privkey
$ ./privkey
Private Key: 032496D7D32AA1A5E1114D68397BA778F7173D24F64A782ABC0DA6258C7497F9
Address: 18z8sD3FHE684c5ubyFVeBLUkU38BRcPL1

Формат импорта кошелька (WIF — Wallet Import Format)

Отлично, теперь у нас есть адрес, на который мы можем отправить биткойн!
Но как мы их тратим?

Большинство программных кошельков НЕ ПРИНИМАЮТ необработанные закрытые ключи.
Вместо этого принято использовать формат импорта кошелька; что, как и в биткойн-адресах, упрощает копирование и передачу закрытого ключа.

НИКОГДА НЕ ХРАНИТЕ БОЛЬШИЕ КОЛИЧЕСТВА BTC НА САМОСОЗДАВАЕМЫХ КОШЕЛЬКАХ

Чтобы преобразовать ваш закрытый ключ в WIF:

1.. Добавьте байт версию (0x80 для основной версии биткоина) в начало закрытого ключа.
2.. Рассчитайте хэш SHA256
3.. Снова вычислите хэш SHA256
4.. Берем из этого хеша первые 4 байта, это наша контрольная сумма
5.. Добавлием эти 4 байта в конец расширенного закрытого ключа на шаге 1.
6.. Преобразуем в base58 (можно повторно использовать функцию написанную ранее)

Если все пройдет правильно, то ваш закрытый ключ WIF должен начинаться с цифры 5.
Для получения дополнительной информации см. wiki/Wallet_import_format.

Ванильные адреса биткойнов

Расширив приведенный выше код, вы можете быстро генерировать новые биткойн-адреса в надежде случайным образом получить красивый адрес, такой как 1LIKEALPACAx88... или 100000xX...

Код из этого руководства, который готов к компиляции и запуску

// Compile with:
// gcc -O2 -lgmp -lcrypto -Wno-deprecated-declarations -lsecp256k1 secp256k1-0.3.0/.libs/libsecp256k1.a  privkey.c -o privkey

#include <stdio.h>

#include "secp256k1-0.3.0/include/secp256k1.h"
#include "secp256k1-0.3.0/include/secp256k1_ecdh.h"

#include <openssl/sha.h>
#include <openssl/ripemd.h>

#include <string.h>

typedef unsigned char byte;


/* See https://en.wikipedia.org/wiki/Positional_notation#Base_conversion */
char* base58(byte *s, int s_size, char *out, int out_size) {
    static const char *base_chars = "123456789"
        "ABCDEFGHJKLMNPQRSTUVWXYZ"
        "abcdefghijkmnopqrstuvwxyz";

    byte s_cp[s_size];
    memcpy(s_cp, s, s_size);

    int c, i, n;

    out[n = out_size] = 0;
    while (n--) {
        for (c = i = 0; i < s_size; i++) {
            c = c * 256 + s_cp[i];
            s_cp[i] = c / 58;
            c %= 58;
        }
        out[n] = base_chars[c];
    }

    return out;
}


static secp256k1_context *ctx = NULL;

int main() {
    ctx = secp256k1_context_create(
    SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
    
    /* Declare the private variable as a 32 byte unsigned char */
    /* Объявляем приватную переменную размером в 32-байта с типом символ без знака */
    unsigned char seckey[32];

    /* Load private key (seckey) from random bytes */
    /* Загрузим закрытый ключ (seckey) из случайных байтов */
    FILE *finput = fopen("/dev/urandom", "r");

    /* Read 32 bytes from finput */
    /* Читаем 32 байта из finput */
    fread(seckey, 32, 1, finput);

    /* Close the file */
    /* Закрываем этот файл */
    fclose(finput);

    if (!secp256k1_ec_seckey_verify(ctx, seckey)) {
        printf("Invalid secret key\n");
    return 1;
    }
    
    /* Loop through and print each byte of the private key, */
    /* Перебираем в цикле и печатаем каждый байт закрытого ключа, */
    printf("Private Key: ");
    for(int i = 0; i < 32; i++) {
        printf("%02X", seckey[i]);
    }
    printf("\n");
    
    
    secp256k1_pubkey pubkey;
    secp256k1_ec_pubkey_create(ctx, &pubkey, seckey);
    
    size_t pk_len = 65;
    char pk_bytes[65];

    /* Serialize Public Key */
    /* Сериализация открытого ключа */
    secp256k1_ec_pubkey_serialize(
        ctx,
        pk_bytes,
        &pk_len,
        &pubkey,
        SECP256K1_EC_UNCOMPRESSED
        );
    
    
    char pubaddress[34];
    byte s[65];
    byte rmd[5 + RIPEMD160_DIGEST_LENGTH];
    
    int j;
    for (j = 0; j < 65; j++) {
        s[j] = pk_bytes[j];
    }
    
    /* Set 0x00 byte for main net */
    /* Устанавливаем 0x00 байт для основной версии биткоин адреса */
    rmd[0] = 0;
    RIPEMD160(SHA256(s, 65, 0), SHA256_DIGEST_LENGTH, rmd + 1);
    
    SHA256(SHA256(rmd, 21, 0), SHA256_DIGEST_LENGTH, 0);
    
    memcpy(rmd + 21, SHA256(SHA256(rmd, 21, 0), SHA256_DIGEST_LENGTH, 0), 4);
    
    char address[34];
    base58(rmd, 25, address, 34);
    
    /* Count the number of extra 1s at the beginning of the address */
    /* Подсчитываем количество лишних 1 в начале адреса */
    int k;
    for (k = 1; address[k] == '1'; k++);

    /* Count the number of extra leading 0x00 bytes */
    /* Подсчитываем количество лишних начальных байтов 0x00 */
    int n;
    for (n = 1; rmd[n] == 0x00; n++);

    /* Remove k-n leading 1's from the address */
    /* Удаляем k-n ведущих единиц из адреса */
    memmove(address, address + (k - n), 34 - (k - n));
    address[34 - (k - n)] = '\0';

    printf("Address: %s\n\n", address);
    
    
    return 0;
}

Протестировать правильность работы нашей программы можно на сайте:
https://www.bitaddress.org/

P.S.:

Если Вы считаете этот пост полезным, то пожалуйста, поддержите меня в создании таких руководств:

USDT (trc20): TTei9TzCvgDsmEoAEdL52w35PALUb4AQ2b
Bitcoin: 3KWuXVHWUwz1BR3zj5nMRWxhAK3YtSMrrU
Litecoin: MLRNskfiRvTGJZPTiMJY8rz5bzRzQmvqD6
Doge: DTLViap4u9F3PZgjKzy5752brQSLJ9TBGg
Dash: XrrxcGZWe16qtrkE9PM7xyJnPcZeWd4RUP