c++ - 如何使用 c++ 和 openssl 防止 TLS GOLDENDOODLE？

Question

有一个用 C++ 和 openssl 制作的简单网络服务器，并且在运行时 SSL Lab's SSL Server Test在上面，它告诉我服务器容易受到 GOLDENDOODLE 和 Sleeping POODLE 的攻击(除其他外，截图 here )，

我正在运行 libopenssl 1.1.1c，这是撰写本文时最新的 openssl 版本，所以我认为这不是使用旧的、过时的易受攻击的 TLS 库的情况，而是我'我可能只是用错了， 因此问题是:您如何使用 openssl 防止 GOLDENDOODLE？这是完整的(易受攻击的？)服务器源代码:

#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <thread>
#include <chrono>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <openssl/ssl.h>
#include <openssl/err.h>

const uint16_t port=443;
int create_socket(const uint16_t port)
{
    int s;
    struct sockaddr_in addr;

    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);

    s = socket(AF_INET, SOCK_STREAM, 0);
    if (s < 0)
    {
        perror("Unable to create socket");
        exit(EXIT_FAILURE);
    }

    if (bind(s, (struct sockaddr*)&addr, sizeof(addr)) < 0)
    {
        perror("Unable to bind");
        exit(EXIT_FAILURE);
    }

    if (listen(s, 1) < 0)
    {
        perror("Unable to listen");
        exit(EXIT_FAILURE);
    }

    return s;
}

void init_openssl()
{
    SSL_load_error_strings();
    OpenSSL_add_ssl_algorithms();
}

void cleanup_openssl()
{
    EVP_cleanup();
}

SSL_CTX *create_context()
{
    const SSL_METHOD *method;
    SSL_CTX *ctx;

    method = SSLv23_server_method();

    ctx = SSL_CTX_new(method);
    if (!ctx)
    {
        perror("Unable to create SSL context");
        ERR_print_errors_fp(stderr);
        exit(EXIT_FAILURE);
    }

    return ctx;
}

void configure_context(SSL_CTX *ctx)
{
//     - Congratulations! Your certificate and chain have been saved at:
//   /etc/letsencrypt/live/fuviewer.ml/fullchain.pem
//   Your key file has been saved at:
//   /etc/letsencrypt/live/fuviewer.ml/privkey.pem

    (void)ctx;

    SSL_CTX_set_ecdh_auto(ctx, 1);

    /* Set the key and cert */
    // SSL_FILETYPE_PEM
    if (SSL_CTX_use_certificate_chain_file(ctx, "fullchain.pem") <= 0)
    {
        ERR_print_errors_fp(stderr);
        exit(EXIT_FAILURE);
    }
    if (SSL_CTX_use_PrivateKey_file(ctx, "privkey.pem", SSL_FILETYPE_PEM) <= 0 )
    {
        ERR_print_errors_fp(stderr);
        exit(EXIT_FAILURE);
    }
}

int main(int argc, char **argv)
{
    (void)argc;
    (void)argv;
    int sock;
    SSL_CTX *ctx;

    init_openssl();
    ctx = create_context();

    configure_context(ctx);

    sock = create_socket(port);
    std::cout << "server running!" << std::flush;
    /* Handle connections */
    while(1)
    {
        struct sockaddr_in addr;
        socklen_t len = sizeof(addr);
        SSL *ssl;
        const char reply[] =
            "HTTP/1.0 200 OK\r\n"
            "Test-header: Yep\r\n"
            "Content-Length: 3\r\n"
            "\r\n"
            "abc";
        const auto reply_size=sizeof(reply)-1;
        int client = accept(sock, (struct sockaddr*)&addr, &len);
        if (client < 0)
        {
            perror("Unable to accept");
            exit(EXIT_FAILURE);
        }

        ssl = SSL_new(ctx);
        SSL_set_fd(ssl, client);

        if (SSL_accept(ssl) <= 0)
        {
            ERR_print_errors_fp(stderr);
        }
        else
        {
            if(SSL_write(ssl, reply, reply_size)!=reply_size)
            {
                throw std::runtime_error("FAILED TO SEND ALL BYTES");
            };
            {
                // openssl gets cranky if we don't try to read at least 1 byte, even tho we don't really want to..
                uint8_t unused;
                SSL_read(ssl,&unused,sizeof(unused));
            }
            SSL_shutdown(ssl);
            //std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        SSL_free(ssl);
        close(client);
    }
    close(sock);
    SSL_CTX_free(ctx);
    cleanup_openssl();
}

Answer 1

虽然关于受影响的 TLS 堆栈的信息很少，但看起来 OpenSSL 应该不会受到攻击，即使在使用 CBC 密码时也是如此。

我认为您看到的是误报，这是由于您的服务器不符合测试预期而触发的。虽然我不知道 SSLLabs 的 GOLDENDOODLE 检测是如何工作的，但我查看了 original detection program from Tripwire .

看起来这个脚本在另一端需要一个合适的 HTTP 服务器，即首先读取请求然后发送响应的服务器。只是，您的服务器以另一种方式执行此操作:首先发送响应并仅在发送响应后读取(并忽略)一些请求。这种非 HTTP 行为没有被考虑(为什么要考虑)并且混淆了导致错误报告不存在的问题的检测。