# Строка ответа и заголовки закодированы в ASCII
48 54 54 50 2f 31 2e 31 20 32 30 30 20 4f 4b 0d 0a  # HTTP/1.1 200 OK\r\n
43 6f 6e 74 65 6e 74 2d 54 79 70 65 3a 20           # Content-Type:⎵
74 65 78 74 2f 68 74 6d 6c 3b 20                    # text/html;⎵
63 68 61 72 73 65 74 3d 75 74 66 2d 38 0d 0a        # charset=utf-8\r\n
43 6f 6e 74 65 6e 74 2d 4c 65 6e 67 74 68 3a 20 32 32 0d 0a         # Content-Length: 22\r\n
0d 0a                                                               # \r\n
# Тело в UTF-8 (потому что так написано в Content-Type)
3c 68 31 3e d0 9f d1 80 d0 b8 d0 b2 d0 b5 d1 82 21 3c 2f 68 31 3e   # <h1>Привет!</h1>

474554202f20485454502f312e310d0a486f73743a206f6b2e72750d0a0d0a

1. Вы впервые подключаетесь к сайту и запускаете видео. Происходит то рукопожатие, которое сейчас обсудим: с помощью DHE.
2. Клиент и сервер генерируют некоторое секретное значение, которое сохраняют на потом — PSK.
3. У вас отключается вай-фай, потому что вы забыли его оплатить. Телефон переключается на мобильный интернет и меняется IP-адрес.
4. Из-за этого TLS соединение разрывается, но видео надо продолжать загружать. Поэтому телефон подключается заново.
5. Телефон отправляет PSK в ClientHello, а сервер его принимает. Тогда сертификат не нужен, и рукопожатие намного короче.

# Заголовок записи
16     # Тип 0x16 — данные рукопожатия
03 03  # Устаревшее поле
00 bb  # Длина содержимого 0xbb = 187 октетов

# Сообщение
01        # Тип ClientHello
00 00 b7  # Длина 0xb7 = 183 октета
03 03     # Устаревшее поле 
# 32 случайных октета
de 74 ae bd 5c 44 a4 5a 35 fa 23 af d7 f1 7f 51 
39 95 7e bb 77 45 87 a6 72 80 81 d1 cd 29 07 d9 
00     # Устаревшее поле (я просто оставил пустым)
00 06  # Длина списка наборов шифров — 6 октетов
13 01  # Клиент поддерживает наборы TLS_AES_128_GCM_SHA256,
13 02  # TLS_AES_256_GCM_SHA384
13 03  # и TLS_CHACHA20_POLY1305_SHA256
01 00  # Устаревшее поле с алгоритмами сжатия
 
# Начинаются расширения
00 88  # Их длина 0x88 = 136 октетов

00 2b  # supported_versions
00 03  # Длина расширения 3 октета
02     # Длина списка 2 октета
03 04  # Клиент поддерживает только TLS 1.3

00 0a  # supported_groups
00 06  # Длина расширения 6 октетов
00 04  # Длина списка 4 октета
00 17  # Клиент поддерживает группу x25519
00 1d  # и secp256r1

00 33  # key_share
00 6b  # Длина расширения 0x6b = 107 октетов
00 69  # Длина списка 0x69 = 105 октетов
00 1d  # Первый ключ для группы x25519
00 20  # Длина ключа 0x20 = 32 октета
# Ключ
71 46 fe c3 d8 78 2c 70 72 ad 84 49 de d7 ef 87 
7c 54 71 44 6b 96 c5 36 f5 d8 b1 57 5f a8 28 4c 
00 17  # Второй ключ для группы secp256r1
00 41  # Длина 0x41 = 65 октетов
# Сам ключ
04 36 f1 4f c7 98 4a b9 c3 48 fa 93 fe 33 1c 4a 
44 39 ae ef 4e dc c1 78 26 bc 8a 3b 9d ce fd 14 
9e 85 9c 50 28 15 65 69 e2 00 dc 19 8b 8e 7a ba 
be 2c a7 53 5e 02 f6 90 ba 9f af d2 3a 3a af 60 46 

00 0d  # signature_algorithms
00 04  # Длина 4 октета
00 02  # Длина списка 2 октета
04 03  # Клиент поддерживает только ecdsa_secp256r1_sha256

16 03 03 00 bb 01 00 00 b7 03 03 de 74 ae bd 5c
44 a4 5a 35 fa 23 af d7 f1 7f 51 39 95 7e bb 77
45 87 a6 72 80 81 d1 cd 29 07 d9 00 00 06 13 01
13 02 13 03 01 00 00 88 00 2b 00 03 02 03 04 00
0a 00 06 00 04 00 17 00 1d 00 33 00 6b 00 69 00
1d 00 20 71 46 fe c3 d8 78 2c 70 72 ad 84 49 de
d7 ef 87 7c 54 71 44 6b 96 c5 36 f5 d8 b1 57 5f
a8 28 4c 00 17 00 41 04 36 f1 4f c7 98 4a b9 c3
48 fa 93 fe 33 1c 4a 44 39 ae ef 4e dc c1 78 26
bc 8a 3b 9d ce fd 14 9e 85 9c 50 28 15 65 69 e2
00 dc 19 8b 8e 7a ba be 2c a7 53 5e 02 f6 90 ba
9f af d2 3a 3a af 60 46 00 0d 00 04 00 02 04 03

# Заголовок записи
16     # Тип 0x16 — данные рукопожатия
03 03  # Устаревшее поле
00 58  # Длина содержимого 0x58 = 88 октетов

# Сообщение
02        # Тип ServerHello
00 00 54 # Длина 0x54 = 84 октета
03 03     # Устаревшее поле
# 32 случайных октета
83 3b d9 07 d8 da 92 2d bc 82 3e 8c 65 5a 0e 2d
1e 09 10 02 a5 44 48 67 0e 28 65 3b 6b 80 ba 2a
00     # У нас LegacySessionId было пустым, так что и тут пустое

13 02  # Сервер выбрал набор шифров TLS_AES_256_GCM_SHA384
00     # Сжатие отключено

# Расширения
00 2c  # Длина всех расширений 0x2c = 44 октета

00 2b  # supported_versions
00 02  # Длина 2 октета
03 04  # Сервер выбрал TLS 1.3

00 33  # key_share
00 24  # Длина 34 октета
00 1d  # Сервер выбрал группу x25519
00 20  # Длина открытого ключа DH 32 октета
# Сам ключ
c5 26 6a b9 ca 84 9b ea 25 da 15 af 7d 91 9a 6d
f2 ae 3e 9c fc b5 bb 6c 29 7f 2d a5 30 28 e7 65

from cryptography.hazmat.primitives import hashes, hmac
from cryptography.hazmat.primitives.kdf.hkdf import HKDFExpand
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey

# Данные из ClientHello/ServerHello, которые нам понадобятся

# Предположим, что выбрали набор TLS_AES_256_GCM_SHA384
hash_algorithm = hashes.SHA384()         # Хеш-функция
digest_size = hash_algorithm.digest_size # Длина результата хеш-функции
cipher_key_length = 32                   # Длина ключа у шифра AES_256_GCM
cipher_iv_length = 12                    # Длина nonce у шифра AES_256_GCM

# Закрытый ключ DH, который клиент/сервер генерирует перед отправкой 
# своего сообщения Hello. Я буду приводить пример вывода ключей для двух 
# алгоритмов DH: x25519 и secp256r1, поэтому тут создаю два ключа.
my_key_share_x25519 = X25519PrivateKey.generate()
my_key_share_secp256r1 = ec.generate_private_key(ec.SECP256R1())

# Содержимое key_share собеседника.
peer_key_share_x25519 = b'...'
peer_key_share_secp256r1 = b'...'

# Стенограммы
client_hello_transcript = bytes.fromhex('01...') # Байты, составляющие ClientHello
server_hello_transcript = bytes.fromhex('02...') # Байты, составляющие ServerHello

def derive_keys_and_iv(client_traffic_secret: bytes, server_traffic_secret: bytes):
    """
    Функция генерации ключей. Принимает два секретных значения. После ServerHello это
    значения client_handshake_traffic_secret и server_handshake_traffic_secret, алгоритм расчёта
    которых ниже. После рукопожатия ключи пересчитаются с другими значениями *_traffic_secret.
    """
    client_write_key = hkdf_expand_label(client_traffic_secret, b'key', b'', cipher_key_length)
    client_write_iv = hkdf_expand_label(client_traffic_secret, b'iv', b'', cipher_iv_length)

    server_write_key = hkdf_expand_label(server_traffic_secret, b'key', b'', cipher_key_length)
    server_write_iv = hkdf_expand_label(server_traffic_secret, b'iv', b'', cipher_iv_length)

    return client_write_key, client_write_iv, server_write_key, server_write_iv

def derive_handshake_secrets(
    psk_share: bytes,
    dhe_share: bytes,
    transcript: bytes,
):
    """
    Генерирует два секретных значения: client_handshake_traffic_secret и server_handshake_traffic_secret.
    Принимает psk_share (мы не обсуждали PSK, так что у нас это просто строка из digest_size нулей);
    dhe_share — результат алгоритма DHE. Пример, как он считается, есть ниже;
    transcript — стенограмма рукопожатия (ClientHello + ServerHello)
    """
    zero_string = b'\0' * digest_size

    early_secret = hkdf_extract(zero_string, psk_share)
    derived_secret = derive_secret(early_secret, b'derived', b'')
    handshake_secret = hkdf_extract(derived_secret, dhe_share)

    client_handshake_traffic_secret = derive_secret(
        handshake_secret, 
        b'c hs traffic', 
        transcript
    )
    server_handshake_traffic_secret = derive_secret(
        handshake_secret, 
        b's hs traffic', 
        transcript
    )

    return handshake_secret, client_handshake_traffic_secret, server_handshake_traffic_secret

# Вспомогательные функции
def hkdf_extract(salt: bytes, input_key_material: bytes) -> bytes:
    """Реализует первую половину алгоритма HKDF (RFC 5869)."""
    hm = hmac.HMAC(salt, hash_algorithm)
    hm.update(input_key_material)
    return hm.finalize()
def encode_vector(length_bytes_count: int, content: bytes):
    """
    Кодирует поле переменной длины, как принято в TLS
    (приписывает в начале длину).
    """
    return len(content).to_bytes(length_bytes_count, 'big') + content
def hkdf_expand_label(secret: bytes, label: bytes, context: bytes, length: bytes) -> bytes:
    """
    Вспомогательная функция. Определена в RFC 8446 (раздел 7.1).
    """
    hkdf_label = (
        length.to_bytes(2, 'big') +
        # Внимание: строка b'tls13 ' с пробелом!
        encode_vector(1, b'tls13 ' + label) +
        encode_vector(1, context)
    )
    hkdf = HKDFExpand(
        algorithm=hashes.SHA384(), 
        length=length, 
        info=hkdf_label,
    )
    return hkdf.derive(secret) 
def derive_secret(secret, label, messages):
    """
    Ещё вспомогательная функция из RFC 8446 (раздел 7.1).
    """

    # Считаем хеш от messages
    h = hashes.Hash(hash_algorithm)
    h.update(messages)
    mesages_hash = h.finalize() 

    return hkdf_expand_label(
        secret=secret, 
        label=label, 
        context=mesages_hash, 
        length=hash_algorithm.digest_size
    )

# Примеры, как получается dhe_share, для групп x25519 и secp256r1.

def derive_x25519_share():
    peer_public_key = X25519PublicKey.from_public_bytes(peer_key_share_x25519)
    return my_key_share_x25519.exchange(peer_public_key)

def derive_secp256r1_share():
    # В cryptography для secp256r1 нет простой функции (по крайней мере я не знаю), 
    # которая распарсит key_share и достанет оттуда открытый ключ (как выше 
    # X25519PublicKey.from_public_bytes). Поэтому приходится парсить вручную.
    curve = ec.SECP256R1()
    curve_key_size = curve.key_size // 8
    curve_x = peer_key_share_secp256r1[1:curve_key_size+1]
    curve_y = peer_key_share_secp256r1[curve_key_size+1:]
    curve_numbers = ec.EllipticCurvePublicNumbers(curve_x, curve_y, curve)
    server_public_key = curve_numbers.public_key()

    return my_key_share_secp256r1.exchange(server_public_key)


# Для примера x25519, можно поменять на secp256r1
selected_group = 'x25519' 

# Проворачиваем алгоритм DHE в зависимости от того,
# какую группу выбрал сервер
match selected_group:
    case 'x25519':
        dhe_share = derive_x25519_share()
    case 'secp256r1':
        dhe_share = derive_secp256r1_share()
    case _:
        raise Exception('Unsupported group')

# handshake_secret пока не нужен, но понадобится для пересчёта ключей
handshake_secret, \
client_handshake_traffic_secret, \
server_handshake_traffic_secret = \
    derive_handshake_secrets(
        # Если бы мы использовали PSK, тут бы был PSK.
        # А так просто куча нулей.
        b'\0' * digest_size,
        dhe_share,
        client_hello_transcript + server_hello_transcript
    )

# Сами ключи
client_write_key, client_write_iv, \
server_write_key, server_write_iv = \
    derive_keys_and_iv(client_handshake_traffic_secret, server_handshake_traffic_secret)

client_write_key = bytes.fromhex('2f1688e9db0251c5efba86aa0e367d797c55e9bad839652c34af645f87e762dc')
client_write_iv  = bytes.fromhex('c8c393817ab1a926a361670e')
server_write_key = bytes.fromhex('636b63af2c0a1e2126e93245f8ebc78449df9fcb29f2d3f1fe948f4f03666923')
server_write_iv  = bytes.fromhex('b5067f19c3b9ec8a26a2072c')

my_key_share_x25519 = X25519PrivateKey.from_private_bytes(bytes.fromhex('7146fec3d8782c7072ad8449ded7ef877c5471446b96c536f5d8b1575fa8284c'))

from cryptography.hazmat.primitives.ciphers.aead import AESGCM

# Ключи, которые получили в предыдущем разделе
server_write_key = bytes.fromhex('636b63af2c0a1e2126e93245f8ebc78449df9fcb29f2d3f1fe948f4f03666923')
server_write_iv  = bytes.fromhex('b5067f19c3b9ec8a26a2072c')

def get_nonce(sequence_number: int, write_iv: bytes):
    xor = lambda x, y: bytes(a ^ b for a, b in zip(x, y))
    # cipher_iv_length определено в разделе про генерацию ключей
    return xor(write_iv, sequence_number.to_bytes(cipher_iv_length, 'big'))

def protect_record(sequence_number: int, write_key: bytes, write_iv: bytes, 
                   type: bytes, content: bytes):
    inner_text = (content + type + 
        # 4 октета дополнения, потому что я так захотел.
        # Можно было больше, можно было меньше, можно вообще без него
        bytes.fromhex('00000000'))
    associated_data = (bytes.fromhex('170303') +
        # Я для примера буду использовать шифр AES_256_GCM. У него 
        # длина результата ровно на 16 больше длины текста.
        # Считаем её (len(inner_text) + 16) и записываем в виде 
        # последовательности из двух октетов.
        (len(inner_text) + 16).to_bytes(2, 'big'))
    # Здесь используется порядковый номер сообщения
    nonce = get_nonce(sequence_number, write_iv)

    # Запускаю алгоритм AES_256_GCM
    aesgcm = AESGCM(write_key)
    protected_content = aesgcm.encrypt(nonce, inner_text, associated_data)

    # Составляем защищённую запись
    protected_record = (
        bytes.fromhex('170303') + # OpaqueType и LegacyRecordVersion
        len(protected_content).to_bytes(2, 'big') + # Длина
        protected_content # Содержимое
    )
    return protected_record


# Пример защиты записи
type = bytes.fromhex('16') # Тип — данные рукопожатия
content = bytes.fromhex('0800001200100010000c000a0008687474702f312e31') # Содержимое
# Это первая защищённая запись, её порядковый номер 0
protected = protect_record(0, server_write_key, server_write_iv,
                           type, content)
print(protected.hex())

16
03 03
04 04 # Длина записи 0x404 = 1028 октетов

0b        # Тип Certificate
00 04 03  # Длина 0x403 = 1027 октетов
00        # Пустое CertificateContext
00 03 ff  # Длина списка сертификатов 0x3ff = 1023 октета
00 01 сe  # Длина первого 0x1ce = 462 октета
30 82 01 ca 30 ... # Сертификат длиной 462 октета
00 00     # Расширений нет
00 02 27  # Длина второго 0x227 = 551 октет
30 82 02 23 30 ... # Сертификат длиной 551 октет
00 00     # Расширений нет

17
03 03 
04 19  # Длина 0x419 = 1049 октетов
9b d8 0b b4...  # 1049 октетов зашифрованного месива

import base64

with open('./chain.crt', 'r') as chain:
    chain = chain.read()
    # В cryptography на самом деле есть функция x509.load_pem_x509_certificates, которая
    # умеет парсить сертификаты в формате PEM. Но я здесь делаю это вручную для наглядности.
    base64_certs = chain \
        .replace('-----BEGIN CERTIFICATE-----', '') \
        .split('-----END CERTIFICATE-----')[:-1]
    certificates = [base64.b64decode(cert) for cert in base64_certs]

def get_certificate_entry(cert_bytes: bytes):
    """Составляем из сертификата CertificateEntry"""
    return (
        len(cert_bytes).to_bytes(3, 'big') + # Длина сертификата
        cert_bytes + # Сам сертификат
        bytes.fromhex('0000') # Список расширений пустой
    )

certificate_list = b''.join(get_certificate_entry(cert) for cert in certificates)
certificate_message_content = (
    bytes.fromhex('00') + # CerificateContext пустое
    len(certificate_list).to_bytes(3, 'big') + # Длина списка
    certificate_list # Сам список
)
certificate_message = (
    bytes.fromhex('0b') + # Тип Certificate
    len(certificate_message_content).to_bytes(3, 'big') + # Длина
    certificate_message_content # Содержимое
)
# Certificate — это вторая защищённая запись (первая была EncryptedExtensions).
# Значение счётчика на ней равно 1.
protected = protect_record(1, server_write_key, server_write_iv,
                           b'\x16', certificate_message)
print(certificate_message.hex())
print(protected.hex())

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import ec

# Хеш-функция из набора шифров — SHA384
hash_algorithm = hashes.SHA384()
# Ключ сервера, который я генерировал в конце первой статьи.
with open('./server.key', 'br') as f:
    signature_private_key = serialization.load_pem_private_key(
        f.read(),
        # В первой статье мы зашифровали ключ, а чтобы что-то подписывать
        # надо его расшифровать. Поэтому здесь указываем пароль.
        password=b'...'
    )

# Стенограммы
client_hello = b'01...'
server_hello = b'02...'
# Те сообщения, что передаются внутри защищённых записей,
# в стенограмме учитываются в расшифрованном виде
encrypted_extensions = b'08...'
certificate = b'0b...'
transcript = client_hello + server_hello + encrypted_extensions + certificate

# Считаем хеш от стенограммы
h = hashes.Hash(hash_algorithm)
h.update(transcript)
transcript_hash = h.finalize()

# Составляем ерунду
signature_content = (
    b'\x20' * 64 + # 64 раза октет 0x20
    b'TLS 1.3, server CertificateVerify' + # Волшебная строка
    b'\x00' + # Октет 0x00
    transcript_hash # Хеш стенограммы
)
# Считаем подпись
algorithm = ec.ECDSA(hashes.SHA256())
signature = signature_private_key.sign(signature_content, algorithm)

certificate_verify_content = (
    bytes.fromhex('0403') + # Алгоритм подписи ecdsa_secp256r1_sha256 
    len(signature).to_bytes(2, 'big') +
    signature
)
certificate_verify = (
    bytes.fromhex('0f') + # Тип сообщения 0x0f
    len(certificate_verify_content).to_bytes(3, 'big') +
    certificate_verify_content
)

# Защищаем запись. CertificateVerify — третье сообщение
# (первое EncryptedExtensions, второе Certificate), значение счётчика 2.
protected_record = protect_record(2, b'\x16', certificate_verify)
print(certificate_verify.hex())
print(protected_record.hex())

from cryptography.hazmat.primitives import hashes, hmac

# Стенограмма. Сюда входят все сообщения от ClientHello до CertificateVerify сервера
transcript = b'01...'

# Функция hkdf_expand_label и переменные digest_size, server_handshake_traffic_secret,
# hash_algorithm такие, как определяли в разделе про генерацию ключей

base_key = server_handshake_traffic_secret
finished_key = hkdf_expand_label(base_key, b'finished', b'', digest_size)

hmac = hmac.HMAC(finished_key, hash_algorithm)
hmac.update(transcript)
verify_data = hmac.finalize()

# Стенограмма рукопожатия от ClientHello до Finished сервера 
# (Finished клиента не учитывается)
transcript = b'01...'

def derive_traffic_secrets():
    zero_string = b'\0' * digest_size
    # handshake_secret здесь из раздела про генерацию ключей.
    # Вспомогательные функции оттуда же.
    derived_secret_2 = derive_secret(handshake_secret, b'derived', b'')
    master_secret = hkdf_extract(derived_secret_2, zero_string)

    client_application_traffic_secret_0 = derive_secret(master_secret, b'c ap traffic', transcript)
    server_application_traffic_secret_0 = derive_secret(master_secret, b's ap traffic', transcript)

    return client_application_traffic_secret_0, server_application_traffic_secret_0 

client_application_traffic_secret_0, server_application_traffic_secret_0 = derive_traffic_secrets()
client_write_key, client_write_iv, server_write_key, server_write_iv = \
    derive_keys_and_iv(client_application_traffic_secret_0, server_application_traffic_secret_0)

# Клиент

# Запрос из начала статьи
http_request = bytes.fromhex('474554202f20485454502f312e310d0a486f73743a206f6b2e72750d0a0d0a')
# Это первое сообщение клиента после пересчёта ключей, его индекс 0.
# Ключи client_write_key и client_write_iv те, что получились в результате пересчёта.
protected_request = protect_record(0, client_write_key, client_write_iv,
                                                     b'\x17', http_request)

# Когда сервер получает этот запрос, он расшифровывает его, потому что
# знает индекс сообщения и значения client_write_key, client_write_iv 

# Сервер
http_response = bytes.fromhex('485454502f312e3120323030204f4b0d0a436f6e74656e742d547970653a20746578742f68746d6c3b20636861727365743d7574662d380d0a436f6e74656e742d4c656e6774683a2032320d0a0d0a3c68313ed09fd180d0b8d0b2d0b5d182213c2f68313e')
# Это первое сообщение сервера после пересчёта, так что индекс опять 0.
protected_response = protect_record(0, server_write_key, server_write_iv,
                                                       b'\x17', http_request)

### Клиент => Сервер ###
16 03 03 00 bb # Заголовок записи
01 00 00 b7    # Сообщение ClientHello, 183 октета
03 03
# 32 случайных октета
de 74 ae bd 5c 44 a4 5a 35 fa 23 af d7 f1 7f 51 
39 95 7e bb 77 45 87 a6 72 80 81 d1 cd 29 07 d9 
00
00 06 13 01 13 02 13 03 # Наборы шифров: TLS_AES_256_GCM_SHA384 и ещё два
01 00 00 88
00 2b 00 03 02 03 04    # supported_versions: TLS 1.3
00 0a 00 06 00 04 00 17 00 1d # supported_groups: x25519, secp256r1
00 33 00 6b 00 69       # key_share
# Для x25519
00 1d 00 20  
71 46 fe c3 d8 78 2c 70 72 ad 84 49 de d7 ef 87 
7c 54 71 44 6b 96 c5 36 f5 d8 b1 57 5f a8 28 4c 
# Для secp256r1
00 17 00 41 
04 36 f1 4f c7 98 4a b9 c3 48 fa 93 fe 33 1c 4a 
44 39 ae ef 4e dc c1 78 26 bc 8a 3b 9d ce fd 14 
9e 85 9c 50 28 15 65 69 e2 00 dc 19 8b 8e 7a ba 
be 2c a7 53 5e 02 f6 90 ba 9f af d2 3a 3a af 60 46 
00 0d 00 04 00 02 04 03 # signature_algorithms: ecdsa_secp256r1_sha256

### Сервер => Клиент ###
16 03 03 00 58
02 00 00 54 03 03 # ServerHello
83 3b d9 07 d8 da 92 2d bc 82 3e 8c 65 5a 0e 2d
1e 09 10 02 a5 44 48 67 0e 28 65 3b 6b 80 ba 2a
00
13 02  # Набор шифров будет TLS_AES_256_GCM_SHA384
00 00 2c
00 2b 00 02 03 04 # Версия TLS: 1.3
00 33 00 24 00 1d 00 20  # Группа: x25519
# Открытый ключ DH
c5 26 6a b9 ca 84 9b ea 25 da 15 af 7d 91 9a 6d
f2 ae 3e 9c fc b5 bb 6c 29 7f 2d a5 30 28 e7 65

# Все последующие записи перед отправкой по сети защищаются.
# Здесь привожу их в расшифрованном виде.

16 03 03 00 06
08 00 00 02 00 00 # EncryptedExtensions, расширений нет

16 03 03 04 04
0b 00 04 03 00 # Certificate
00 03 ff 
# Первый сертификат (листовой)
00 01 сe 30 82 01 ca 30 ... 00 00
# Второй (промежуточный)
00 02 27 30 82 02 23 30 ... 00 00

16 03 03 00 50
0f 00 00 4c 04 03  # CertificateVerify, алгоритм ecdsa_secp256r1_sha256
00 48 2f 93 c1 ... # Подпись закрытым ключом ЭП сервера

# В этот момент клиент проверяет, что доверят сертификату,
# и что подпись верна

16 03 03 00 24
14 00 00 20     # Finished
82 aa b1 ...    # HMAC от стенограммы рукопожатия

### Клиент => Сервер ###

16 03 03 00 24
14 00 00 20     # Finished
92 28 eb ...    # HMAC от стенограммы рукопожатия

17 03 03 00 1f  # Запись 0x17 (данные приложения)
47 45 54 20 ... # HTTP-запрос

### Сервер => Клиент ###
17 03 03 00 65
48 54 54 50 ... # HTTP-ответ

import socket

# Налаживаем TCP-соединение
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect(("google.com", 443))
    
    s.sendall(b'160303...') # Отправляем запись с ClientHello
    response_type = s.recv(1) # Смотрим на первый байт ответа
    if response_type == b'\0x16':
       # Если тип записи — данные рукопожатия, парсим ServerHello
       ...
    else: ...