test

    if (mHash.size() != 32)

        throwSSL(NetException::Error, "SHA256 hash failed");

    fprintf(stderr, "[TLS] _rsa_sha256_pkcs15_sign: input size=%zu, hash size=%zu\n", in.size(), mHash.size());

    fprintf(stderr, "[TLS] SHA256 hash: ");

    for (int i = 0; i < 16; i++) fprintf(stderr, "%02x ", mHash[i]);

    fprintf(stderr, "...\n");

    // PKCS#1 v1.5 signature digest info for SHA256:

    // DigestInfo ::= SEQUENCE {

    //   digestAlgorithm DigestAlgorithmIdentifier,

    };

    const size_t sha256_prefix_len = sizeof(sha256_prefix) / sizeof(sha256_prefix[0]);

    fprintf(stderr, "[TLS] SHA256 DigestInfo prefix (%zu bytes): ", sha256_prefix_len);

    for (size_t i = 0; i < sha256_prefix_len; i++) fprintf(stderr, "%02x ", sha256_prefix[i]);

    fprintf(stderr, "\n");

    // Build DigestInfo: prefix || hash

    std::vector<uint8_t> tBuf;

    tBuf.insert(tBuf.end(), sha256_prefix, sha256_prefix + sha256_prefix_len);

    tBuf.insert(tBuf.end(), mHash.begin(), mHash.end());

    fprintf(stderr, "[TLS] DigestInfo total size=%zu\n", tBuf.size());

    // Build PKCS#1 v1.5 encoded message

    size_t modBytes = (_rsa.n.bitLength() + 7) / 8;

    fprintf(stderr, "[TLS] RSA modulus bits=%u, bytes=%zu\n", _rsa.n.bitLength(), modBytes);

    if (tBuf.size() > modBytes - 11)

        throwSSL(NetException::Error, "Message too long for RSA key");

    // Copy digest info

    std::memcpy(&EM[modBytes - tBuf.size()], tBuf.data(), tBuf.size());

    fprintf(stderr, "[TLS] PKCS#1 EM encoding: [00 01 FF...FF 00 DigestInfo]\n");

    fprintf(stderr, "[TLS] EM (first 20 bytes): ");

    for (int i = 0; i < 20 && i < (int)EM.size(); i++) fprintf(stderr, "%02x ", EM[i]);

    fprintf(stderr, "\n");

    fprintf(stderr, "[TLS] EM (last 20 bytes): ");

    for (int i = (int)EM.size() - 20; i < (int)EM.size(); i++)

        if (i >= 0) fprintf(stderr, "%02x ", EM[i]);

    fprintf(stderr, "\n");

    // Perform raw RSA operation: signature = EM^d mod n

    rsa::bigInt m = rsa::bytesToBigIntBE(EM);

    rsa::bigInt s = rsa::modPow(m, _rsa.d, _rsa.n);

    std::vector<uint8_t> sig = rsa::bigIntToBytesBE(s, modBytes);

    fprintf(stderr, "[TLS] Final RSA signature size=%zu (should be %zu)\n", sig.size(), modBytes);

    return sig;

}

std::vector<uint8_t> netplus::ssl::_ecdsa_sha256_sign(const std::vector<uint8_t>& in){

    if (!_has_ec_key) throwSSL(NetException::Error, "TLS1.3: no EC private key");

    std::cerr << "[ECDSA] Starting signature generation" << std::endl;

    // 1. Hash the message with SHA-256

    std::vector<uint8_t> hash = sha256_hash(in);

        if (u256_cmp(k_val, P256_N) < 0) break;

    }

    std::cerr << "[ECDSA] Generated k" << std::endl;

    // 3. Compute R = k*G

    P256Point R = scalar_mul_G(k_bytes);

    if (R.inf) throwSSL(NetException::Error, "ECDSA: R at infinity");

    std::cerr << "[ECDSA] Computed R = k*G" << std::endl;

    // 4. Get r = R.x mod n

    std::vector<uint8_t> rx_be = encode_tls_point(R);

    // rx_be is 65 bytes: 04 || X(32) || Y(32), extract X

    // Check r != 0

    if (u256_is_zero(r_val)) throwSSL(NetException::Error, "ECDSA: r = 0");

    std::cerr << "[ECDSA] r computed" << std::endl;

    // 5. Convert hash (z) and private key (d) to u256

    u256 z_val = u256_from_be(hash.data());

    u256 d_val = u256_from_be(_ec_priv);

    // Third: k_inv = k^-1 mod n

    u256 k_inv = scalar_inv_mod_n(k_val);

    std::cerr << "[ECDSA] Computed k^-1" << std::endl;

    // Fourth: s = k_inv * sum mod n

    u256 s_val = scalar_mul_mod_n(k_inv, sum);

    // Check s != 0

    if (u256_is_zero(s_val)) throwSSL(NetException::Error, "ECDSA: s = 0");

    std::cerr << "[ECDSA] s computed" << std::endl;

    // 7. Convert r and s back to big-endian bytes

    uint8_t r_be[32], s_be[32];

    u256_to_be(r_be, r_val);