# 配置构建（启用所有功能）
python3 configure.py --with-zlib --with-bzip2 --with-lzma

# 配置构建（最小化构建）
python3 configure.py --without-documentation

# 使用 CMake（实验性）
mkdir build && cd build
cmake .. -DBOTAN_WITH_TLS=ON -DBOTAN_WITH_X509=ON

#include <botan/tls_client.h>
#include <botan/tls_callbacks.h>

class TLSCallbacks : public Botan::TLS::Callbacks {
    void tls_emit_data(const uint8_t data[], size_t size) override {
        // 发送数据到网络
        send_to_network(data, size);
    }
    void tls_record_received(u64 seq, const uint8_t data[], size_t size) override {
        // 处理接收到的应用数据
        process_data(data, size);
    }
};

int main() {
    TLSCallbacks callbacks;
    Botan::TLS::Policy policy;  // 使用默认策略
    Botan::TLS::Session_Manager session_manager;
    Botan::RandomNumberGenerator& rng = Botan::system_rng();

    Botan::TLS::Client client(callbacks, session_manager, policy, rng);

    // 连接到服务器
    client.set_hostname("example.com");
    client.set_port(443);
    client.handshake();

    // 发送请求
    client.send("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n");
}

#include <botan/tls_policy.h>

class PostQuantumPolicy : public Botan::TLS::Policy {
public:
    std::vector<std::string> allowed_key_exchange_methods() override {
        // 启用 ML-KEM（Kyber）混合密钥交换
        return {
            "ECDH_P256_MLKEM768",
            "ECDH_X25519_MLKEM768",
        };
    }
};

#include <botan/rsa.h>
#include <botan/pk_sign.h>
#include <botan/pubkey.h>

// 生成密钥
Botan::RSA_PrivateKey rsa_key(rng, 3072);

// 签名
Botan::PK_Signer signer(rsa_key, rng, "EMSA3(SHA-256)");
signer.update(message);
std::vector<uint8_t> signature = signer.signature();

// 验证
Botan::PK_Verifier verifier(rsa_key, "EMSA3(SHA-256)");
verifier.update(message);
bool valid = verifier.check_signature(signature);

#include <botan/ed25519.h>

// 生成密钥
Botan::Ed25519_PrivateKey ed_key(rng);

// 签名
Botan::PK_Signer ed_signer(ed_key, rng, "Raw");
ed_signer.update(message);
std::vector<uint8_t> ed_signature = ed_signer.signature();

// 验证
Botan::Ed25519_PublicKey ed_pub(ed_key);
Botan::PK_Verifier ed_verifier(ed_pub, "Raw");
ed_verifier.update(message);
bool ed_valid = ed_verifier.check_signature(ed_signature);

#include <botan/ml_dsa.h>

// 生成 ML-DSA-65（对应 AES-192 安全级别）
Botan::MLDSA_PrivateKey mldsa_key(rng, Botan::MLDSA::Mode::MLDSA_65);

// 签名
Botan::PK_Signer mldsa_signer(mldsa_key, rng, "Raw");
mldsa_signer.update(message);
std::vector<uint8_t> mldsa_sig = mldsa_signer.signature();

#include <botan/aead.h>
#include <botan/cipher_mode.h>

// 生成密钥和 IV
Botan::SymmetricKey key(rng, 32);  // 256-bit
Botan::InitializationVector iv(rng, 12);  // 96-bit for GCM

// 创建 cipher
auto enc = Botan::Cipher_Mode::create("AES-256/GCM", Botan::Cipher_Dir::Encryption);
enc->set_key(key);
enc->start(iv);
enc->finish(plaintext, 0);

std::vector<uint8_t> ciphertext = enc->next_vec();
std::vector<uint8_t> mac = enc->mac();  // GCM authentication tag

auto chacha = Botan::Cipher_Mode::create("ChaCha20-Poly1305", Botan::Cipher_Dir::Encryption);
chacha->set_key(key);
chacha->start(iv);
chacha->finish(plaintext, 0);

#include <botan/hash.h>

// SHA-256
auto sha256 = Botan::HashFunction::create("SHA-256");
sha256->update(data);
std::vector<uint8_t> hash = sha256->final();

// BLAKE2b（通常更快）
auto blake2b = Botan::HashFunction::create("BLAKE2b-512");
blake2b->update(data);
std::vector<uint8_t> hash512 = blake2b->final();

#include <botan/argon2.h>

std::string password = "user_password";
std::string salt = Botan::hex_encode(rng.random_vec(16));

// Argon2id（推荐参数）
std::string hash = Botan::argon2_generate_pbkdf(
    password,
    salt,
    3,      // iterations
    32,     // output length
    1 << 20 // memory (1 MiB)
);

// 验证
bool ok = Botan::argon2_check_pbkdf(hash, password);

#include <botan/x509_cert.h>
#include <botan/certstor.h>

// 加载证书
Botan::X509_Certificate cert("server.pem");
Botan::X509_Certificate root("ca.pem");

// 创建验证对象
Botan::Certificate_Store_In_Memory store;
store.add_certificate(root);

Botan::Path_Validation_Result result = Botan::x509_path_validate(
    cert,
    store,
    Botan::Path_Validation_Restrictions::standard(),
    "example.com"  // 验证主机名
);

if (result.successful_validation()) {
    printf("Certificate valid for example.com\n");
}

# Ubuntu/Debian
sudo apt install botanist libbotan-3-dev

# Fedora
sudo dnf install botan3 botan3-devel

# macOS (Homebrew)
brew install botan

# Arch Linux
sudo pacman -S botan

# 克隆仓库
git clone https://github.com/randombit/botan.git
cd botan

# 配置构建
python3 configure.py --with-zlib --with-bzip2 --with-lzma

# 编译
make -j$(nproc)

# 安装
sudo make install

# 更新库缓存
sudo ldconfig

python3 configure.py --amalgamation
# 生成 botan_all.h 和 botan_all.cpp
g++ -o botan_app botan_all.cpp -lz -lbz2 -llzma -pthread

# 使用 pip（需要先构建库）
pip3 install botan3

# 或从源码安装 Python 绑定
cd botan
python3 setup.py install

from botan import HashFunction, Cipher, PK Signer, TLS

# SHA-256 哈希
sha256 = HashFunction.create("SHA-256")
sha256.update(b"hello world")
digest = sha256.final()
print(digest.hex())

# AES-256-GCM 加密
key = Cipher.generate_key("AES-256")
enc = Cipher.create("AES-256/GCM/NoPadding")
enc.set_key(key)
ct, tag = enc.encrypt(b"secret message", nonce)

#include <botan/ffi.h>

botan_pubkey_t pubkey;
botan_load_pubkey(&pubkey, "key.pem");

botan_hash_t hash;
botan_hash_init(&hash, "SHA-256", 0);
botan_hash_update(hash, data, data_len);
uint8_t hash_out[32];
botan_hash_final(hash, hash_out);
botan_hash_destroy(hash);

# 哈希计算
botan hash SHA-256 data.txt

# 加密文件
botan encrypt AES-256/GCM key.txt plaintext.bin ciphertext.bin

# 生成随机数
botan rng 32 > random.bin

# 密钥生成
botan keygen RSA --bits 3072 --output rsa.pem
botan keygen Ed25519 --output ed25519.pem

# 证书验证
botan verify server.pem --ca-certs ca.pem --hostname example.com

#include <botan/pkcs11.h>

// 加载 PKCS#11 模块
Botan::PKCS11::Module pkcs11("/usr/lib/librtpkcs11.so");

// 打开会话
Botan::PKCS11::Session session(pkcs11, 0, Botan::PKCS11::Session::RW);

// 登录（如果需要 PIN）
session.login(user_pin, Botan::PKCS11::Session::User);

// 获取私钥
auto private_key = session.get_private_key(key_id);

// 使用私钥签名
Botan::PK_Signer signer(*private_key, rng, "SHA-256");
signer.update(data);
auto signature = signer.signature();

#include <botan/tpm2.h>

// 创建 TPM 上下文
Botan::TPM2::Context tpm;

// 加载 EK（认可密钥）
auto ek = tpm.load_public_key("ek.pub");

// 创建 SRK（存储主密钥）
auto srk = tpm.create_srk(rng, "AES-256");

// 注册自定义哈希函数
Botan::HashFunction::register_algorithm("MyHash", [](size_t out_len) {
    return std::make_unique<MyHashFunction>();
});

// 使用自定义哈希
auto my_hash = Botan::HashFunction::create("MyHash");

#include <botan/tls_server.h>
#include <boost/asio.hpp>

class TLSStream {
    Botan::TLS::Server server;
    boost::asio::ip::tcp::socket socket;

public:
    TLSStream(boost::asio::io_context& io, Botan::TLS::Policy& policy)
        : server(callbacks, session_mgr, policy, rng)
        , socket(io)
    {}

    // 异步读写接口...
};

// 使用安全的随机数生成器
Botan::AutoSeeded_RNG rng;

// RSA 至少 3072 位（2026 年后推荐 4096 位）
Botan::RSA_PrivateKey rsa_key(rng, 3072);

// ECDSA 使用 P-256 或更高级曲线
Botan::EC_Group secp256r1("secp256r1");
Botan::ECDSA_PrivateKey ecdsa_key(rng, secp256r1);

class SecurePolicy : public Botan::TLS::Policy {
public:
    std::vector<uint16_t> allowed_ciphersuites() override {
        return {
            TLS_13_AES_256_GCM_SHA384,
            TLS_13_CHACHA20_256_POLY1305_SHA256,
        };
    }

    std::vector<std::string> allowed_key_exchange_methods() override {
        return {
            "ECDH_P256",
            "ECDH_X25519",
            "ECDH_P256_MLKEM768",  // 后量子混合
        };
    }

    bool allow_tls12() const override { return false; }  // 仅 TLS 1.3
};

try {
    Botan::Cipher_Mode::create("AES-256/GCM", Botan::Cipher_Dir::Encryption);
} catch (const Botan::Algorithm_Not_Found& e) {
    // 算法不支持
} catch (const Botan::Invalid_Key_Length& e) {
    // 密钥长度错误
}

// 验证返回值
auto hash = Botan::HashFunction::create("SHA-256");
if (!hash) {
    // 创建失败
}

# 命令行测试
botan version
botan hash SHA-256 < /dev/urandom | head -c 64

# C++ 测试
echo '#include <botan/version.h>
int main(){ printf("%s\n", Botan::version_string()); }' | \
g++ -x c++ -I/usr/include/botan-3 -lbotan-3 -o version - && ./version

# Python 测试
python3 -c "from botan import version; print(version)"

# Android NDK
./configure.py --os=android --cpu=arm64