TCP input TLS - Add Ssl, wrapper around SSL.

Author: BonnyAD9

src/plugins/input/tcp/CMakeLists.txt

@@ -13,6 +13,7 @@ add_library(tcp-input MODULE
     src/Acceptor.cpp
     src/Plugin.cpp
     src/IpxPlugin.cpp
+    src/tls/Ssl.cpp
 )
 
 if (CMAKE_HOST_SYSTEM_NAME STREQUAL "FreeBSD" OR CMAKE_HOST_SYSTEM_NAME STREQUAL "OpenBSD")

src/plugins/input/tcp/src/tls/Ssl.cpp

@@ -0,0 +1,55 @@
+/**
+ * \file
+ * \author Jakub Antonín Štigler <[email protected]>
+ * \brief Wrapper around SSL from OpenSSL. (source file)
+ * \date 2025
+ *
+ * Copyright: (C) 2023 CESNET, z.s.p.o.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "Ssl.hpp"
+
+namespace tcp_in {
+namespace tls {
+
+bool Ssl::accept() {
+    auto res = SSL_accept(get());
+    if (res <= 0) {
+        auto err = SSL_get_error(get(), res);
+        // Nonblocking client needs to wait.
+        if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
+            return false;
+        }
+        throw_ssl_err(err, "Failed performing TLS handshake with client ({}).");
+    }
+    return true;
+}
+
+ReadResult Ssl::read_ex(std::vector<std::uint8_t> &buf) {
+    buf.resize(buf.capacity());
+    std::size_t len;
+    auto ret = SSL_read_ex(get(), buf.data(), buf.size(), &len);
+
+    if (ret <= 0) {
+        auto err = SSL_get_error(get(), ret);
+        buf.resize(0);
+        switch (err) {
+            case SSL_ERROR_ZERO_RETURN:
+                return ReadResult::FINISHED;
+            case SSL_ERROR_SYSCALL:
+                return ReadResult::CLOSED;
+            case SSL_ERROR_WANT_READ:
+            case SSL_ERROR_WANT_WRITE:
+                return ReadResult::WAIT;
+            default:
+                throw_ssl_err(err, "SSL failed to read data.");
+        }
+    }
+
+    buf.resize(std::min(len, buf.size()));
+    return ReadResult::READ;
+}
+
+} // namespace tls
+} // namespace tcp_in

src/plugins/input/tcp/src/tls/Ssl.hpp

@@ -0,0 +1,140 @@
+/**
+ * \file
+ * \author Jakub Antonín Štigler <[email protected]>
+ * \brief Wrapper around SSL from OpenSSL. (header file)
+ * \date 2025
+ *
+ * Copyright: (C) 2023 CESNET, z.s.p.o.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include <openssl/ssl.h>
+
+#include "SslBio.hpp"
+#include "throw_ssl_err.hpp"
+
+namespace tcp_in {
+namespace tls {
+
+namespace dealloc {
+
+/** Deletor for `SSL` from OpenSSL. Can be used for example in `std::unique_ptr` */
+class Ssl {
+public:
+    void operator()(SSL *ssl) { SSL_free(ssl); }
+};
+
+} // namespace dealloc
+
+/** Describes result of read operation. */
+enum class ReadResult {
+    /** Successufully read some data. */
+    READ,
+    /** Non blocking socket needs to wait for more data. */
+    WAIT,
+    /** Peer will not send any further data. */
+    FINISHED,
+    /** The connection has been closed. (socket cannot read) */
+    CLOSED,
+};
+
+/**
+ * @brief Wrapper around `SSL` from OpenSSL.
+ *
+ * This is basically io stream for data encrypted with TLS.
+ */
+class Ssl : public std::unique_ptr<SSL, dealloc::Ssl> {
+public:
+    /** Unique pointer of `SSL`. This is base class for `Ssl`. */
+    using SelfPtr = std::unique_ptr<SSL, dealloc::Ssl>;
+
+    /**
+     * @brief Construct `Ssl` from the given `SSL_CTX`.
+     * @param ctx Base context for the ssl object.
+     * @throws If failed to create new bio.
+     */
+    Ssl(SSL_CTX *ctx) : SelfPtr(SSL_new(ctx)) {
+        if (!get()) {
+            throw_ssl_err("Failed to create SSL object.");
+        }
+    }
+
+    /**
+     * @brief Set the bio object from which this will read data.
+     * @param bio Bio object from which to read. This will take ownership of the given `SslBio`.
+     */
+    void set_bio(SslBio bio) noexcept {
+        auto raw_bio = bio.release();
+        SSL_set_bio(get(), raw_bio, raw_bio);
+    }
+
+    /**
+     * @brief Set the server name for SNI.
+     * @param hostname Name of the server.
+     * @throws On failure.
+     */
+    void set_tlsext_host_name(const char *hostname) {
+        if (!SSL_set_tlsext_host_name(get(), hostname)) {
+            throw_ssl_err("Failed to set the SNI hostname.");
+        }
+    }
+
+    /**
+     * @brief Set the expected DNS name of the server.
+     * @param hostname Hostname of the server.
+     * @throws On failure.
+     */
+    void set1_host(const char *hostname) {
+        if (!SSL_set1_host(get(), hostname)) {
+            throw_ssl_err(
+                "Failed to set the cergificate verification hostname."
+            );
+        }
+    }
+
+    /**
+     * @brief Perform TLS handshake.
+     *
+     * In case of nonblocking server, this can be multiple times to continue the tls handshake.
+     * @returns `true` if TLS handshake is successfully complete. `false` if the tls handshake is
+     * incomplete because the underlaying socket is nonblocking and it needs to wait for more data.
+     * @throws On failure.
+     */
+    bool accept();
+
+    /**
+     * @brief Read application data from the TLS connection.
+     *
+     * @param [out] buf Will be cleared. The read data will be put here. Up to the capacity of the
+     * buffer will be used.
+     * @return result of the read operation:
+     * - `READ`: Successfully read some data. `buf` shouldn't be empty.
+     * - `WAIT`: Non blocking socket needs to wait for more data. `buf` should be empty.
+     * - `FINISHED`: Peer will not send any further data. `buf` should be empty.
+     * - `CLOSED`: The connection has been closed. (socket cannot read) `buf` should be empty.
+     * @throws On failure.
+     */
+    ReadResult read_ex(std::vector<std::uint8_t> &buf);
+
+    /**
+     * @brief Shuts the connection down.
+     * @return `true` on successful shutdown, false if shutdown is in process but not complete yet.
+     * @throws On failure.
+     */
+    bool shutdown() {
+        auto ret = SSL_shutdown(get());
+        if (ret < 0) {
+            throw_ssl_err("SSL failed to shutdown connection.");
+        }
+        return ret == 1;
+    }
+};
+
+} // namespace tls
+} // namespace tcp_in