Fuzzing Bitcoin: Поиск критической уязвимости и новые методы защиты криптовалюты

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

Фаззинг-тестирование (или просто Фаззинг) — это метод тестирования программного обеспечения, который используется для выявления уязвимостей и ошибок путем подачи на вход программы случайных или специально сгенерированных данных. В контексте криптоанализа Фаззинг-тестирование применяется для проверки криптографических алгоритмов и систем на наличие слабых мест, которые могут быть использованы злоумышленниками.

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

Фаззинг-тестирование в криптоанализе может помочь обнаружить такие проблемы, как:

1. Буферные переполнения: Ошибки, возникающие при записи данных за пределы выделенной памяти.
2. Ошибки обработки исключений: Неправильная обработка неожиданных или некорректных данных.
3. Уязвимости в алгоритмах: Недостатки в реализации криптографических алгоритмов, которые могут быть использованы для взлома.

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

Применение Фаззинг-тестирования к криптовалютным кошелькам имеет несколько преимуществ:

1. Обнаружение уязвимостей: Фаззинг помогает выявить уязвимости, которые могут быть использованы злоумышленниками для кражи средств или компрометации безопасности кошелька.
2. Повышение надежности: Тестирование с использованием случайных данных помогает выявить ошибки, которые могут привести к сбоям или некорректной работе кошелька, что в свою очередь повышает его надежность.
3. Автоматизация процесса тестирования: Фаззинг-тестирование можно автоматизировать, что позволяет проводить тесты более часто и эффективно, чем ручное тестирование.
4. Разнообразие тестовых сценариев: Фаззинг генерирует большое количество разнообразных тестовых сценариев, что помогает выявить ошибки, которые могли бы остаться незамеченными при использовании традиционных методов тестирования.
5. Улучшение безопасности: Регулярное Фаззинг-тестирование помогает разработчикам своевременно обнаруживать и устранять уязвимости, что повышает общий уровень безопасности криптовалютного кошелька.
6. Экономия времени и ресурсов: Автоматизированное Фаззинг-тестирование может сэкономить время и ресурсы, которые в противном случае были бы потрачены на ручное тестирование и отладку.

Фаззинг может помочь обнаружить следующие типы уязвимостей:

1. Ошибки обработки ввода: Кошельки могут некорректно обрабатывать входные данные, такие как адреса, суммы транзакций или ключи. Фаззинг может выявить случаи, когда некорректные данные приводят к сбоям или неправильной работе кошелька.
2. Переполнение буфера: Если Биткоин кошелек не проверяет длину входных данных, это может привести к переполнению буфера, что в свою очередь может быть использовано злоумышленниками для выполнения произвольного кода.
3. Уязвимости в парсерах: Кошельки часто используют парсеры для обработки данных транзакций и других входных данных. Фаззинг может выявить ошибки в этих парсерах, которые могут привести к сбоям или уязвимостям безопасности.
4. Ошибки в криптографических операциях: Некорректная обработка данных в криптографических операциях может привести к утечке приватных ключей или другим критическим уязвимостям. Фаззинг может помочь выявить такие ошибки.
5. Уязвимости в API: Если Биткоин кошелек предоставляет API для взаимодействия с другими приложениями, Фаззинг может выявить уязвимости в этих интерфейсах, которые могут быть использованы для несанкционированного доступа или выполнения нежелательных операций.
6. Ошибки в обработке транзакций: Фаззинг может выявить ошибки в логике обработки транзакций, которые могут привести к неправильному выполнению транзакций или даже к потере средств.

BitcoinChatGPT и выбор инструмента для Фаззинга:

Существует множество инструментов для Фаззинг-тестирования, таких как AFL (American Fuzzy Lop), libFuzzer, Honggfuzz и другие. Фаззинг-тестирование должно быть частью непрерывного процесса разработки и тестирования. Регулярное проведение Фаззинг-тестов поможет своевременно выявлять новые уязвимости и поддерживать высокий уровень безопасности криптовалютного кошелька. В начале 2024 года широкую популярность получили современные технологии которые развивают предварительно обученную модель Bitcoin ChatGPT и находят эффективные способы решение сложных криптографических задач, лежащих в основе метода Фаззинг-тестирования. Рассмотрим пример построение структуры уязвимой Raw транзакции в котором используется модуль BitcoinChatGPT

BitcoinChatGPT №3 Fuzzing Vulnerability Algorithm

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

AFL (American Fuzzy Lop)

Это один из самых популярных инструментов для Фаззинг-тестирования. Он может быть настроен для тестирования различных типов программного обеспечения, включая криптовалютные кошельки. American Fuzzy Lop (AFL) — это мощный инструмент для Фаззинг-тестирования, который обычно используется для нахождения уязвимостей в программном обеспечении. Хотя AFL в основном используется через командную строку, вы можете написать Python-скрипт для автоматизации его запуска. Для начала, убедитесь, что у вас установлен AFL. Если нет, вы можете установить его, следуя инструкциям на официальном сайте AFL.

На YouTube можно найти множество полезных видеороликов, которые помогут вам лучше понять и использовать AFL. Вот несколько рекомендаций:

1. “American Fuzzy Lop (AFL) Tutorial” — В этом видео обычно объясняются основы использования AFL, как его установить и начать работу с ним.
2. “Fuzzing with AFL: A Practical Guide” — Это видео может предложить практическое руководство по Фаззинг-тестированию с использованием AFL, включая примеры и демонстрации.
3. “Advanced Fuzzing Techniques with AFL” — В этом видео могут быть рассмотрены более продвинутые техники и стратегии для эффективного использования AFL.
4. “AFL Fuzzing: Finding Bugs in Real-World Applications” — Это видео может показать, как использовать AFL для нахождения уязвимостей в реальных приложениях, с примерами и анализом.
5. “Setting Up AFL for Fuzz Testing” — В этом видео может быть пошагово показано, как настроить AFL для Фаззинг-тестирования на вашей системе.

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

Пример Python-скрипта, который запускает AFL:

#!/usr/bin/env python
import os
import subprocess

# Path to the AFL executable
afl_path = "/path/to/afl-fuzz"

# Path to the program under test
target_program = "/path/to/target_program"

# Path to the directory with input data
input_dir = "/path/to/input_dir"

# Path to the directory to save the output
output_dir = "/path/to/output_dir"

# Additional arguments for the program under test
target_args = "arg1 arg2"

# Forming a team to launch AFL
command = f"{afl_path} -i {input_dir} -o {output_dir} -- {target_program} {target_args}"

# Launch AFL
try:
subprocess.run(command, shell=True, check=True)
print("AFL started successfully.")
except subprocess.CalledProcessError as e:
print(f"Error starting AFL: {e}")




In this script:

- afl_path — path to the AFL executable file (afl-fuzz).
- target_program — path to the program under test.
- input_dir — path to the directory with input data for fuzzing.
- output_dir — path to the directory to save the output data.
- target_args — additional arguments for the program under test.

This script generates a command to run AFL and executes it using subprocess.run. If AFL starts successfully, a corresponding message is displayed. If an error occurs, an error message is displayed.

Be sure to replace paths and arguments with appropriate values ​​for your environment and program under test.

Этот скрипт выполняет следующие шаги:

1. Определяет пути к AFL, целевому исполняемому файлу, директории с входными данными и директории для результатов.
2. Формирует команду для запуска AFL с указанными параметрами.
3. Запускает команду с помощью
   subprocess.run

libFuzzer

Это библиотека для Фаззинг-тестирования, которая интегрируется с LLVM. Она может быть использована для тестирования программ на C и C++. LibFuzzer — это инструмент для fuzz-тестирования, который обычно используется с C/C++ программами. Однако, вы можете использовать Python для автоматизации запуска LibFuzzer.

1. “Introduction to Fuzzing with libFuzzer” – Этот видеоролик предоставляет базовое введение в использование libFuzzer для начинающих.
2. “Fuzzing with libFuzzer and AddressSanitizer” – В этом видео объясняется, как использовать libFuzzer вместе с AddressSanitizer для обнаружения уязвимостей в коде.
3. “Advanced Fuzzing Techniques with libFuzzer” – Этот ролик подходит для тех, кто уже знаком с основами и хочет углубить свои знания.
4. “Google Testing Blog: libFuzzer Tutorial” – Видеоурок от команды Google, который охватывает различные аспекты использования libFuzzer.
5. “Fuzzing C/C++ Programs with libFuzzer” – В этом видео рассматриваются конкретные примеры и демонстрируется процесс Фаззинга C/C++ программ.

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

Пример кода на Python, который запускает LibFuzzer:

#!/usr/bin/env python
import subprocess

def run_libfuzzer(target_binary, corpus_dir, timeout=60):
"""
Runs LibFuzzer on the specified binary in the given corpus directory.

:param target_binary: Path to the binary file that will be fuzz tested.
:param corpus_dir: Path to the corpus directory.
:param timeout: Execution time in seconds (default 60 seconds).
"""
try:
# Command to run LibFuzzer
command = [target_binary, corpus_dir, '-max_total_time={}'.format(timeout)]

# Start process
process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

# Wait for process to complete
stdout, stderr = process.communicate()

# Output results
print("LibFuzzer output:\n", stdout.decode())
if stderr:
print("LibFuzzer errors:\n", stderr.decode())

except Exception as e:
print(f"An error occurred while starting LibFuzzer: {e}")

# Usage example
target_binary = "./path/to/your/fuzz_target"
corpus_dir = "./path/to/your/corpus"
run_libfuzzer(target_binary, corpus_dir)

Этот скрипт выполняет следующие шаги:

1. Определяет функцию run_libfuzzer, которая принимает путь к бинарному файлу, каталог корпуса и необязательное время выполнения.
2. Формирует команду для запуска LibFuzzer с указанными параметрами.
3. Запускает процесс с помощью subprocess.Popen и ожидает его завершения.
4. Выводит результаты выполнения и любые ошибки.

Убедитесь, что у вас установлен и скомпилирован бинарный файл с поддержкой LibFuzzer, и что у вас есть каталог с тестовыми данными (корпус).

Honggfuzz

Это еще один мощный инструмент для Фаззинг-тестирования, который поддерживает различные типы программного обеспечения и может быть использован для тестирования криптовалютных кошельков. Honggfuzz — это мощный инструмент для fuzz-тестирования, который можно запускать из Python с помощью модуля subprocess.

1. “Fuzzing with Honggfuzz” – Этот видеоролик может предоставить вам общее представление о том, как начать работу с Honggfuzz, включая установку и базовые команды.
2. “Advanced Fuzzing Techniques with Honggfuzz” – В этом видео могут быть рассмотрены более продвинутые техники и настройки для использования Honggfuzz, что может быть полезно для более опытных пользователей.
3. “Honggfuzz Tutorial for Beginners” – Если вы только начинаете, этот видеоролик может быть отличным стартом, так как он, вероятно, охватывает основные концепции и шаги по настройке.
4. “Integrating Honggfuzz with CI/CD Pipelines” – Это видео может показать, как интегрировать Honggfuzz в ваши процессы непрерывной интеграции и доставки, что может быть полезно для автоматизации тестирования.

Пример кода, который демонстрирует, как это сделать:

#!/usr/bin/env python
import subprocess

# Path to the Honggfuzz executable
honggfuzz_path = "/path/to/honggfuzz"

# Path to the application under test
target_app = "/path/to/target_app"

# Path to the directory with input data for fuzz testing
input_dir = "/path/to/input_dir"

# Path to the directory to save the results
output_dir = "/path/to/output_dir"

# Arguments for running Honggfuzz
args = [
honggfuzz_path,
"--input", input_dir,
"--output", output_dir,
"--", target_app
]

#LaunchHonggfuzz
try:
result = subprocess.run(args, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
print("Honggfuzz started successfully!")
print("Stdout output:", result.stdout.decode())
print("Stderr output:", result.stderr.decode())
except subprocess.CalledProcessError as e:
print("Error starting Honggfuzz!")
print("Error code:", e.returncode)
print("stdout output:", e.stdout.decode())
print("Stderr output:", e.stderr.decode())

В этом примере:

honggfuzz_path – путь к исполняемому файлу Honggfuzz.

target_app – путь к тестируемому приложению.

input_dir – путь к директории с входными данными для fuzz-тестирования.

output_dir – путь к директории для сохранения результатов.

Этот скрипт использует модуль subprocess для запуска Honggfuzz с заданными аргументами.

Не забудьте заменить пути к honggfuzz, target_app, input_dir и output_dir на соответствующие пути в вашей системе.

OSS-Fuzz

Это сервис от Google, который предоставляет инфраструктуру для непрерывного Фаззинг-тестирования с открытым исходным кодом. Он поддерживает множество проектов и может быть настроен для тестирования криптовалютных кошельков. OSS-Fuzz помогает находить ошибки в программном обеспечении с открытым исходным кодом с помощью fuzz-тестирования. Однако, OSS-Fuzz не запускается напрямую через Python-код. Вместо этого, вы должны настроить проект для использования OSS-Fuzz, а затем запустить его через командную строку.

Рассмотрим пример того, как можно настроить и запустить fuzz-тестирование для вашего проекта с использованием OSS-Fuzz.

1. “OSS-Fuzz: Continuous Fuzzing for Open Source Software” – Этот видеоролик от Google Open Source рассказывает о том, как работает OSS-Fuzz и как он помогает улучшать безопасность и стабильность открытого программного обеспечения.
2. “Fuzzing with OSS-Fuzz” – В этом видео подробно объясняется, как начать использовать OSS-Fuzz для вашего проекта, включая настройку и интеграцию.
3. “Google OSS-Fuzz: Continuous Fuzzing for Open Source Software” – Презентация от Google, которая охватывает основные концепции и преимущества использования OSS-Fuzz.
4. “Fuzzing 101: Getting Started with OSS-Fuzz” – Учебное пособие для начинающих, которое шаг за шагом объясняет, как начать работу с OSS-Fuzz.
5. “Integrating Your Project with OSS-Fuzz” – В этом видео рассматриваются практические аспекты интеграции вашего проекта с OSS-Fuzz, включая примеры кода и советы по устранению неполадок.

Вот основные шаги:

1. Настройка проекта для OSS-Fuzz:

• Создайте Dockerfile для вашего проекта.
• Напишите скрипт сборки для вашего проекта.

1. Запуск OSS-Fuzz:

• Используйте командную строку для запуска Docker-контейнера и выполнения fuzz-тестов.

Пример Dockerfile и скрипта сборки:

Dockerfile:

Dockerfile
FROM gcr.io/oss-fuzz-base/base-builder
RUN apt-get update && apt-get install -y make cmake

# Copy your project to the container
COPY. $SRC/your_project

# Go to the project directory
WORKDIR $SRC/your_project

# Run the build script
RUN ./build.sh

uild.sh:

bash
#!/bin/bash -eu

# Install the compiler for fuzz testing
export CC=clang
export CXX=clang++

# Create a build directory
mkdir build
cd build

# Run cmake and make to build the project
cmake..
make

# Compile the fuzz test
$CXX $CXXFLAGS -std=c++11 -I . \
$SRC/your_project/fuzz_target.cpp -o $OUT/fuzz_target \
$LIB_FUZZING_ENGINE



fuzz_target.cpp:

cpp
#include
#include

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
// Your code for fuzz testing
return 0;
}

После того как вы настроили Dockerfile и скрипт сборки, вы можете запустить OSS-Fuzz с помощью следующих команд:

sh
# Build the Docker image
docker build -t oss-fuzz/your_project .

# Run fuzz testing
docker run --rm -v $PWD/out:/out oss-fuzz/your_project

Эти шаги помогут вам настроить и запустить fuzz-тестирование для вашего проекта с использованием OSS-Fuzz. Если у вас есть конкретные вопросы или вам нужна помощь с настройкой, пожалуйста, дайте знать!

Radamsa

Это генератор случайных данных, который может быть использован для Фаззинг-тестирования. Он прост в использовании и может быть интегрирован в различные тестовые сценарии. Radamsa — это инструмент для генерации случайных данных (fuzzing), который может быть полезен для тестирования программного обеспечения.

1. Fuzzing with Radamsa” – В этом видео объясняется, как использовать Radamsa для Фаззинга (тестирования программного обеспечения на наличие уязвимостей).
2. “Introduction to Fuzz Testing with Radamsa” – Введение в Фазз-тестирование с использованием Radamsa, включая основные принципы и примеры.
3. “Radamsa: A Fuzzing Tool for Security Testing” – Обзор возможностей Radamsa и его применения в области безопасности.
4. “How to Use Radamsa for Fuzz Testing” – Пошаговое руководство по использованию Radamsa для Фазз-тестирования.

Чтобы запустить Radamsa из Python, вы можете использовать модуль subprocess для выполнения командной строки.

Пример кода:

1. Убедитесь, что Radamsa установлен на вашем компьютере. Вы можете установить его с помощью
   brew
   на macOS или собрать из исходников на других системах.
2. Используйте следующий Python код для запуска Radamsa:

#!/usr/bin/env python
import subprocess

def run_radamsa(input_file, output_file):
try:
# Run Radamsa specifying input and output files
subprocess.run(['radamsa', input_file, '-o', output_file], check=True)
print(f"Fuzzed data has been written to {output_file}")
except subprocess.CalledProcessError as e:
print(f"An error occurred while running Radamsa: {e}")

# Usage example
input_file = 'input.txt'
output_file = 'output.txt'

run_radamsa(input_file, output_file)



In this example:
-
input_file
is the path to the file you want to use as input to Radamsa.
-
output_file
— this is the path to the file in which the data generated by Radamsa will be written.

Этот код запускает Radamsa с указанными входным и выходным файлами и выводит сообщение о завершении работы или ошибке, если она произошла. Убедитесь, что файлы input.txt и output.txt существуют в той же директории, что и ваш скрипт, или укажите полный путь к ним.

Echidna

Это инструмент для Фаззинг-тестирования смарт-контрактов на языке Solidity, который может быть полезен для тестирования кошельков, взаимодействующих с Ethereum.

1. “Echidna: Fuzzing for Ethereum Smart Contracts” – Этот видеоролик объясняет основы использования Echidna для тестирования смарт-контрактов на Ethereum.
2. “Fuzzing Smart Contracts with Echidna” – В этом видео подробно рассматривается процесс настройки и запуска Echidna для Фаззинга смарт-контрактов.
3. “Echidna: A Fuzzer for Ethereum Smart Contracts” – В этом видео обсуждаются различные аспекты и возможности Echidna, а также примеры использования.
4. “Smart Contract Security: Fuzzing with Echidna” – Видеоролик, который фокусируется на безопасности смарт-контрактов и использовании Echidna для нахождения уязвимостей.

Чтобы запустить Echidna с помощью Python, вам нужно будет использовать команду оболочки (shell command) из Python.

Пример кода, который показывает, как это можно сделать:

1. Убедитесь, что у вас установлен Echidna. Вы можете установить его, следуя инструкциям на официальной странице проекта.
2. Используйте модуль subprocess в Python для запуска Echidna.

#!/usr/bin/env python
import subprocess

# Path to your smart contract
contract_path = "path/to/your/contract.sol"

# Command to run Echidna
command = ["echidna-test", contract_path]

try:
# Run command
result = subprocess.run(command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)

# Output the result
print("Echidna output:")
print(result.stdout)
except subprocess.CalledProcessError as e:
print("An error occurred while running Echidna:")
print(e.stderr)

Этот скрипт запускает Echidna для указанного смарт-контракта и выводит результат в консоль. Убедитесь, что вы заменили path/to/your/contract.sol на фактический путь к вашему смарт-контракту.

Peach Fuzzer

Коммерческий инструмент для Фаззинг-тестирования, который поддерживает множество протоколов и форматов данных. Он может быть использован для тестирования безопасности криптовалютных кошельков. Peach Fuzzer — это популярная платформа Фаззинга, используемая для проверки безопасности и надежности программного обеспечения путем предоставления неожиданных или случайных входных данных.

1. “Peach Fuzzer Tutorial” – В этом видео обычно объясняются основы использования Peach Fuzzer, включая установку и настройку.
2. “Fuzzing with Peach: A Beginner’s Guide” – Это видео может быть полезно для тех, кто только начинает работать с Peach Fuzzer и хочет понять основные концепции и методы.
3. “Advanced Peach Fuzzer Techniques” – В этом видео рассматриваются более сложные аспекты использования Peach Fuzzer, такие как создание собственных тестов и анализ результатов.
4. “Peach Fuzzer in Action: Real-World Examples” – Здесь можно увидеть, как Peach Fuzzer используется для нахождения уязвимостей в реальных приложениях.
5. “Setting Up a Fuzzing Environment with Peach” – Это видео поможет вам настроить рабочую среду для эффективного использования Peach Fuzzer.

Peach Fuzzer не написан на Python, и для его запуска обычно требуются файлы конфигурации и определенные шаги настройки.

Чтобы запустить Peach Fuzzer, вам обычно необходимо создать XML-файл Peach Pit, который определяет структуру данных, которые вы хотите Фаззить, и целевое приложение. Затем вы используете инструмент командной строки Peach для выполнения процесса Фаззинга.

Вот базовый пример того, как вы можете настроить и запустить Peach Fuzzer, используя Python для вызова инструмента командной строки. В этом примере предполагается, что в вашей системе установлен и правильно настроен Peach Fuzzer.

Создайте XML-файл Peach Fuzzer (например,пример.xml):

Python script to run Peach Fuzzer:

#!/usr/bin/env python
import subprocess

def run_peach_fuzzer(peach_pit_file):
try:
# Command to run Peach Fuzzer
command = ['peach', peach_pit_file]

# Execute the command
result = subprocess.run(command, capture_output=True, text=True)

# Print the output
print("Peach Fuzzer Output:")
print(result.stdout)

# Check for errors
if result.stderr:
print("Peach Fuzzer Errors:")
print(result.stderr)
except Exception as e:
print(f"An error occurred: {e}")

# Path to the Peach Pit XML file
peach_pit_file = 'example.xml'

# Run the Peach Fuzzer
run_peach_fuzzer(peach_pit_file)

Этот сценарий использует Python модуль subprocess для вызова инструмента командной строки Peach Fuzzer с указанным XML-файлом Peach Pit.
Обязательно замените «example.xml» путем к фактическому файлу Peach Fuzzer.

Примечание: В этом примере предполагается, что команда peach доступна в PATH вашей системы. Если это не так, вам может потребоваться указать полный путь к исполняемому файлу Peach. Кроме того, убедитесь, что у вас есть необходимые разрешения для запуска Peach Fuzzer и что все зависимости установлены правильно.

Заключение:

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

References:

• 1. “Fuzzing for Security Testing: Theory and Practice” – review articles on methods and techniques fuzzing.
• 2. “Bitcoin: A Peer-to-Peer Electronic Cash System” is an original article by Satoshi Nakamoto describing the basics of Bitcoin.
• 3. “Fuzzing: Art, Science, and Engineering” – articles describing various approaches to fuzzing and their application in security.
• 4. “Fuzzing for Software Security Testing and Quality Assurance” – a book dedicated to fuzzing methods and tools.
• 5. “Mastering Bitcoin: Unlocking Digital Cryptocurrencies” is a book that provides a deep understanding of how Bitcoin works.
• 6. “Looking for Lacunae in Bitcoin Core’s Fuzzing Efforts” Dynamic analysis: Software testing and debugging
• 7. “ContractFuzzer: Fuzzing Smart Contracts for Vulnerability Detection” Bo Jiang, Ye Liu, and W.K. Chan. 2018. ContractFuzzer: Fuzzing Smart Contracts for Vulnerability Detection
• 8. “Fuzzing Ethereum Smart Contracts” Roberto Ponte and Miguel Correia INESC-ID, Instituto Superior Tecnico, Universidade de Lisboa / Iberia Medeiros LaSIGE, Faculdade de Ciencias, Universidade de Lisboa.
• 9. “TokenAuditor: Detecting Manipulation Risk in Token Smart Contract by Fuzzing” 2022 IEEE 22nd International Conference on Software Quality, Reliability and Security (QRS).
• 10. “Learning to Fuzz from Symbolic Execution” with Application to Smart Contracts.
• 11. “Finding Consensus Bugs in Ethereum via Multi-transaction Differential Fuzzing” Youngseok Yang, Seoul National University; Taesoo Kim, Georgia Institute of Technology; Byung-Gon Chun, Seoul National University and FriendliAI
• 12. “The Human Side of Fuzzing: Challenges Faced by Developers” During Fuzzing Activities (Software testing and debugging; Empirical studies; Surveys and overviews).

Данный материал создан для портала CRYPTO DEEP TECH для обеспечения финансовой безопасности данных и криптографии на эллиптических кривых secp256k1 против слабых подписей ECDSA в криптовалюте BITCOIN. Создатели программного обеспечения не несут ответственность за использование материалов.

Исходный код

Google Colab

BitcoinChatGPT

Telegram: https://t.me/cryptodeeptech

Видеоматериал: https://youtu.be/CU4CFoxgKc8

Dzen Video Tutorial: https://dzen.ru/video/watch/665f6986a2886608ad194e31

Источник: https://cryptodeep.ru/fuzzing-bitcoin

Криптоанализ