LibTLS: Rename MessageType to ContentType

This matches the wording used in the TLS RFC

Userland/Libraries/LibTLS/Extensions.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2020, Ali Mohammad Pur <mpfard@serenityos.org>
+ * Copyright (c) 2023, stelar7 <dudedbz@gmail.com>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Types.h>
+
+namespace TLS {
+
+#define _ENUM_KEY(name) name,
+#define _ENUM_KEY_VALUE(name, value) name = value,
+
+// https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-5
+#define __ENUM_CONTENT_TYPES                \
+    _ENUM_KEY_VALUE(CHANGE_CIPHER_SPEC, 20) \
+    _ENUM_KEY_VALUE(ALERT, 21)              \
+    _ENUM_KEY_VALUE(HANDSHAKE, 22)          \
+    _ENUM_KEY_VALUE(APPLICATION_DATA, 23)   \
+    _ENUM_KEY_VALUE(HEARTBEAT, 24)          \
+    _ENUM_KEY_VALUE(TLS12_CID, 25)          \
+    _ENUM_KEY_VALUE(ACK, 26)
+
+enum class ContentType : u8 {
+    __ENUM_CONTENT_TYPES
+};
+
+#undef _ENUM_KEY
+#undef _ENUM_KEY_VALUE
+
+}

Userland/Libraries/LibTLS/Handshake.cpp

@@ -22,7 +22,7 @@ ByteBuffer TLSv12::build_hello()
 
     auto packet_version = (u16)m_context.options.version;
     auto version = (u16)m_context.options.version;
-    PacketBuilder builder { MessageType::Handshake, packet_version };
+    PacketBuilder builder { ContentType::HANDSHAKE, packet_version };
 
     builder.append((u8)ClientHello);
 
@@ -152,7 +152,7 @@ ByteBuffer TLSv12::build_hello()
 
 ByteBuffer TLSv12::build_change_cipher_spec()
 {
-    PacketBuilder builder { MessageType::ChangeCipher, m_context.options.version, 64 };
+    PacketBuilder builder { ContentType::CHANGE_CIPHER_SPEC, m_context.options.version, 64 };
     builder.append((u8)1);
     auto packet = builder.build();
     update_packet(packet);
@@ -162,7 +162,7 @@ ByteBuffer TLSv12::build_change_cipher_spec()
 
 ByteBuffer TLSv12::build_handshake_finished()
 {
-    PacketBuilder builder { MessageType::Handshake, m_context.options.version, 12 + 64 };
+    PacketBuilder builder { ContentType::HANDSHAKE, m_context.options.version, 12 + 64 };
     builder.append((u8)HandshakeType::Finished);
 
     // RFC 5246 section 7.4.9: "In previous versions of TLS, the verify_data was always 12 octets

Userland/Libraries/LibTLS/HandshakeClient.cpp

@@ -309,7 +309,7 @@ void TLSv12::build_ecdhe_rsa_pre_master_secret(PacketBuilder& builder)
 
 ByteBuffer TLSv12::build_certificate()
 {
-    PacketBuilder builder { MessageType::Handshake, m_context.options.version };
+    PacketBuilder builder { ContentType::HANDSHAKE, m_context.options.version };
 
     Vector<Certificate const&> certificates;
     Vector<Certificate>* local_certificates = nullptr;
@@ -369,7 +369,7 @@ ByteBuffer TLSv12::build_client_key_exchange()
         return {};
     }
 
-    PacketBuilder builder { MessageType::Handshake, m_context.options.version };
+    PacketBuilder builder { ContentType::HANDSHAKE, m_context.options.version };
     builder.append((u8)HandshakeType::ClientKeyExchange);
 
     switch (get_key_exchange_algorithm(m_context.cipher)) {

Userland/Libraries/LibTLS/Record.cpp

@@ -16,7 +16,7 @@ namespace TLS {
 
 ByteBuffer TLSv12::build_alert(bool critical, u8 code)
 {
-    PacketBuilder builder(MessageType::Alert, (u16)m_context.options.version);
+    PacketBuilder builder(ContentType::ALERT, (u16)m_context.options.version);
     builder.append((u8)(critical ? AlertLevel::Critical : AlertLevel::Warning));
     builder.append(code);
 
@@ -69,8 +69,8 @@ void TLSv12::update_packet(ByteBuffer& packet)
     u32 header_size = 5;
     ByteReader::store(packet.offset_pointer(3), AK::convert_between_host_and_network_endian((u16)(packet.size() - header_size)));
 
-    if (packet[0] != (u8)MessageType::ChangeCipher) {
+    if (packet[0] != (u8)ContentType::CHANGE_CIPHER_SPEC) {
-        if (packet[0] == (u8)MessageType::Handshake && packet.size() > header_size) {
+        if (packet[0] == (u8)ContentType::HANDSHAKE && packet.size() > header_size) {
             u8 handshake_type = packet[header_size];
             if (handshake_type != HandshakeType::HelloRequest && handshake_type != HandshakeType::HelloVerifyRequest) {
                 update_hash(packet.bytes(), header_size);
@@ -319,7 +319,7 @@ ssize_t TLSv12::handle_message(ReadonlyBytes buffer)
         return (i8)Error::NeedMoreData;
     }
 
-    auto type = (MessageType)buffer[0];
+    auto type = (ContentType)buffer[0];
     size_t buffer_position { 1 };
 
     // FIXME: Read the version and verify it
@@ -346,7 +346,7 @@ ssize_t TLSv12::handle_message(ReadonlyBytes buffer)
 
     ByteBuffer decrypted;
 
-    if (m_context.cipher_spec_set && type != MessageType::ChangeCipher) {
+    if (m_context.cipher_spec_set && type != ContentType::CHANGE_CIPHER_SPEC) {
         if constexpr (TLS_DEBUG) {
             dbgln("Encrypted: ");
             print_buffer(buffer.slice(header_size, length));
@@ -489,7 +489,7 @@ ssize_t TLSv12::handle_message(ReadonlyBytes buffer)
     m_context.remote_sequence_number++;
 
     switch (type) {
-    case MessageType::ApplicationData:
+    case ContentType::APPLICATION_DATA:
         if (m_context.connection_status != ConnectionStatus::Established) {
             dbgln("unexpected application data");
             payload_res = (i8)Error::UnexpectedMessage;
@@ -505,11 +505,11 @@ ssize_t TLSv12::handle_message(ReadonlyBytes buffer)
             }
         }
         break;
-    case MessageType::Handshake:
+    case ContentType::HANDSHAKE:
         dbgln_if(TLS_DEBUG, "tls handshake message");
         payload_res = handle_handshake_payload(plain);
         break;
-    case MessageType::ChangeCipher:
+    case ContentType::CHANGE_CIPHER_SPEC:
         if (m_context.connection_status != ConnectionStatus::KeyExchange) {
             dbgln("unexpected change cipher message");
             auto packet = build_alert(true, (u8)AlertDescription::UnexpectedMessage);
@@ -521,7 +521,7 @@ ssize_t TLSv12::handle_message(ReadonlyBytes buffer)
             m_context.remote_sequence_number = 0;
         }
         break;
-    case MessageType::Alert:
+    case ContentType::ALERT:
         dbgln_if(TLS_DEBUG, "alert message of length {}", length);
         if (length >= 2) {
             if constexpr (TLS_DEBUG)

Userland/Libraries/LibTLS/Socket.cpp

@@ -61,7 +61,7 @@ ErrorOr<size_t> TLSv12::write_some(ReadonlyBytes bytes)
     }
 
     for (size_t offset = 0; offset < bytes.size(); offset += MaximumApplicationDataChunkSize) {
-        PacketBuilder builder { MessageType::ApplicationData, m_context.options.version, bytes.size() - offset };
+        PacketBuilder builder { ContentType::APPLICATION_DATA, m_context.options.version, bytes.size() - offset };
         builder.append(bytes.slice(offset, min(bytes.size() - offset, MaximumApplicationDataChunkSize)));
         auto packet = builder.build();
 

Userland/Libraries/LibTLS/TLSPacketBuilder.h

@@ -10,16 +10,10 @@
 #include <AK/ByteReader.h>
 #include <AK/Endian.h>
 #include <AK/Types.h>
+#include <LibTLS/Extensions.h>
 
 namespace TLS {
 
-enum class MessageType : u8 {
-    ChangeCipher = 0x14,
-    Alert = 0x15,
-    Handshake = 0x16,
-    ApplicationData = 0x17,
-};
-
 enum class Version : u16 {
     V10 = 0x0301,
     V11 = 0x0302,
@@ -29,12 +23,12 @@ enum class Version : u16 {
 
 class PacketBuilder {
 public:
-    PacketBuilder(MessageType type, u16 version, size_t size_hint = 0xfdf)
+    PacketBuilder(ContentType type, u16 version, size_t size_hint = 0xfdf)
         : PacketBuilder(type, (Version)version, size_hint)
     {
     }
 
-    PacketBuilder(MessageType type, Version version, size_t size_hint = 0xfdf)
+    PacketBuilder(ContentType type, Version version, size_t size_hint = 0xfdf)
     {
         // FIXME: Handle possible OOM situation.
         m_packet_data = ByteBuffer::create_uninitialized(size_hint + 16).release_value_but_fixme_should_propagate_errors();