Возникла на днях достаточно интересная задачка - по образу сайта https://www.howsmyssl.com/ получить на страничке список Cipher Suites которые при TLS Handshake клиент передает в своем Client hello.

А заодно обдумать инструмент, который позволит работать с другими типами заголовков, в частности - Proxy-Connection.

В качестве основного веб сервера с которым я имею дело выступает Nginx, точнее его сборка Openresty с интерпретатором LuaJIT для скриптов Lua.

Основная проблематика связана с тем, что веб серверу напрямую доступно очень немногое что относится к процедуре TLS Handshake.
Соответственно и перехватывать процедуру хендшейка логично на более низком уровне.

Неизбежно возникают некоторые сопутствующие моменты, например что Session ID из клиентского заголовка не будет равняться Session ID серверного ответа и переменной ngx.var.ssl_session_id

В принципе, можно пойти и по совсем простому пути:

• Перехватить пакеты через Tshark для клиентского приветствия и ответа сервера, и передавать вывод скрипту на Python:
  tshark -i eth0 -Y 'ssl.handshake.type == 1 or ssl.handshake.type == 2 ' -l -V | python3 tcpparse.py

• В скрипте Python реализовать логику определения какой из двух пакетов нам пришел.
  Взаимосвязь между клиентским и северным приветствием определять по Acknowledgment number клиентского пакета, который будет равен Sequence Number серверного пакета. Из серверного пакета брать Session ID и результаты кешировать.

Но так как задача предполагала некий задел на будущее, я решил не использовать tshark, а ограничиться модулем stream в Nginx:

stream {
    server {
        listen 443;
        content_by_lua_file "/lua/simpleproxy.lua";
    }

}

local function proxy_data(client_sock, server_sock)
    local ok1, err = ngx.thread.spawn(read_from_socket_client, client_sock, server_sock)
    if not ok1 then
        ngx.log(ngx.ERR, "failed to spawn read_from_socket_client thread: ", err)
        return
    end
    local ok2, err = ngx.thread.spawn(read_from_socket_server, server_sock, client_sock)
    if not ok2 then
        ngx.log(ngx.ERR, "failed to spawn read_from_socket_server thread: ", err)
        return
    end
    ngx.thread.wait(ok1, ok2)
end

local function proxy_handler_stream()
    local client_sock, err = ngx.req.socket(true)
    if not client_sock then
        ngx.log(ngx.ERR, "failed to get client socket: ", err)
        return ngx.exit(ngx.ERROR)
    end
    local server_sock = ngx.socket.tcp()
    local ok, err = server_sock:connect("127.0.0.1", 8443)
    if not ok then
        ngx.log(ngx.ERR, "failed to connect to the server: ", err)
        return ngx.exit(ngx.ERROR)
    end
    proxy_data(client_sock, server_sock)
end

proxy_handler_stream()

Функция proxy_handler_stream инициирует чтение данных из клиентского сокета, инициализирует соединение с бекендом, и передает управление функции proxy_data, которая использует механизм "Light threads" который является одной из реализаций корутин в Lua

Минималистично, для пересылки пакетов между клиентом и сервером достаточно такого кода функций read_from_socket_client и read_from_socket_server:

local function read_from_socket_client(from_sock, to_sock)
    from_sock:settimeout(0)
    to_sock:settimeout(0)
    while true do
        local data, err, partial = from_sock:receive("1")
        if not data and err == "closed" then
            break
        end
        data = data or partial
        if data and #data > 0 then
            local bytes, send_err = to_sock:send(data)
            if not bytes then
                return false, "failed to send data: " .. send_err
            end
        end
    end
end

local function read_from_socket_server(from_sock, to_sock)
    from_sock:settimeout(0)
    to_sock:settimeout(0)
    while true do
        local data, err, partial = from_sock:receive("1")
        if not data and err == "closed" then
            break
        end
        data = data or partial
        if data and #data > 0 then
            local bytes, send_err = to_sock:send(data)
            if not bytes then
                return false, "failed to send data: " .. send_err
            end
        end
    end
end

Однако наша задача не ограничивается проксированием, поэтому начнем бубны с танцами.
Модифицируем read_from_socket_client и read_from_socket_server. Из данных передаваемых через сокеты нам нужно отбросить первые 5 байт (если честно - я не помню зачем они, сорри). 6 байт будет содержать код заголовка (01 - клиентский hello, 02 - серверный ответ), далее - 3 байта длины сообщения. Далее читать и агрегировать данные нам не нужно, и мы просто продолжаем пересылку:

local accumulated_data_client = ""
local accumulated_data_server = ""
local counter_client = -5
local counter_client_stop = 4096
local counter_server = -5
local counter_server_stop = 4096

local function read_from_socket_client(from_sock, to_sock)
    from_sock:settimeout(0)
    to_sock:settimeout(0)
    while true do
        local data, err, partial = from_sock:receive("1")
        if not data and err == "closed" then
            break
        end
        data = data or partial
        if data and #data > 0 then
            counter_client = counter_client + 1
            if counter_client > 0 and counter_client <= counter_client_stop then
                accumulated_data_client = accumulated_data_client .. data
                if counter_client == 4 then
                    local last_three_bytes = accumulated_data_client:sub(2, 4)
                    local result = 0
                    for i = 1, #last_three_bytes do
                        result = result * 256 + last_three_bytes:byte(i)
                    end
                    counter_client_stop = result + 4
                end
            end
            local bytes, send_err = to_sock:send(data)
            if not bytes then
                return false, "failed to send data: " .. send_err
            end
        end
    end
end

local function read_from_socket_server(from_sock, to_sock)
    from_sock:settimeout(0)
    to_sock:settimeout(0)
    while true do
        local data, err, partial = from_sock:receive("1")
        if not data and err == "closed" then
            break
        end
        data = data or partial
        if data and #data > 0 then
            counter_server = counter_server + 1
            if counter_server > 0 and counter_server <= counter_server_stop then
                accumulated_data_server = accumulated_data_server .. data
                if counter_server == 4 then
                    local last_three_bytes = accumulated_data_server:sub(2, 4)
                    local result = 0
                    for i = 1, #last_three_bytes do
                        result = result * 256 + last_three_bytes:byte(i)
                    end
                    counter_server_stop = result + 4
                end
            end
            if counter_server == counter_server_stop then
                infoFromHandshake(accumulated_data_client, accumulated_data_server)
            end
            local bytes, send_err = to_sock:send(data)
            if not bytes then
                return false, "failed to send data: " .. send_err
            end
        end
    end
end

В коде выше, когда counter_server достигает конца полезной нагрузки заголовка, происходит вызов функции infoFromHandshake. Она наконец получает переменные, содержащие клиентский запрос и серверный ответ на него. 

Хотя в серверном ответе и содержится SessionID в открытом виде, однако информации о Cipher Suites в клиентском запросе в явном виде не будет. И самое простое из известных мне решений для дальнейшего декодирования заголовков - использовать библиотеку cryptobyte, написанную на Go. 

Поэтому покамест быстренько напишем передачу данных через пайп нашей будущей программе на Go, ответ запишем в Redis и оставим Lua в покое:

local function infoFromHandshake(data_client, data_server)

    local timestamp = os.time()
    local randomPart = math.random(10000, 99999)
    local tempInputClientFileName = string.format("/tmp/hs_client_input_%d_%d.txt", timestamp, randomPart)
    local tempInputServerFileName = string.format("/tmp/hs_server_input_%d_%d.txt", timestamp, randomPart)

    local tempInputClientFile = io.open(tempInputClientFileName, "w")
    tempInputClientFile:write(data_client)
    tempInputClientFile:close()

    local tempInputServerFile = io.open(tempInputServerFileName, "w")
    tempInputServerFile:write(data_server)
    tempInputServerFile:close()

    local go_program_client = assert(io.popen("/ciphersuites/clienthello < " .. tempInputClientFileName, "r"))
    local clienthello = assert(go_program_client:read("*a"))
    go_program_client:close()
    os.remove(tempInputClientFileName)

    local go_program_server = assert(io.popen("/ciphersuites/clienthello < " .. tempInputServerFileName, "r"))
    local sessionid = assert(go_program_server:read("*a"))
    go_program_server:close()
    os.remove(tempInputServerFileName)

    if sessionid and clienthello then
        setRedisKeys(sessionid, clienthello)
    else
        return
    end

end

Функцию setRedisKeys не привожу, она простая до безобразия.

В приложении на Go прочитаем данные из пайпа, и определим по первому байту тип заголовка:

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"os"
)

func main() {
	var buf bytes.Buffer
	_, err := io.Copy(&buf, os.Stdin)
	if err != nil {
		fmt.Fprintln(os.Stderr, "Ошибка при чтении:", err)
		return
	}
	data := buf.Bytes()
	if len(data) < 1 {
		fmt.Fprintln(os.Stderr, "Нет данных для чтения")
		return
	}
	switch data[0] {
	case 0x01:
		ClientDecode(data)
	case 0x02:
		ServerDecode(data)
	default:
		fmt.Fprintln(os.Stderr, "Неизвестный заголовок")
	}
}

func ClientDecode(data []byte) {
	clientInfo := UnmarshalClientHello(data)
	clientInfoJson, err := json.Marshal(clientInfo)
	if err != nil {
		fmt.Println("Ошибка при кодировании в JSON:", err)
		return
	}
	fmt.Printf(string(clientInfoJson))
}
func ServerDecode(data []byte) {
	server_info := UnmarshalServerResponse(data)
	serverSessionID := server_info.SessionIDHex
	fmt.Printf(string(serverSessionID))
}

За основу кода на Go для дешифровки взята эта статья: https://www.agwa.name/blog/post/parsing_tls_client_hello_with_cryptobyte

package main
import (
	"bytes"
	"encoding/json"
    "encoding/hex"
    "crypto/cryptobyte"
  	"fmt"
	"io"
	"os"
)
func main() {
	var buf bytes.Buffer
	_, err := io.Copy(&buf, os.Stdin)
	if err != nil {
		fmt.Fprintln(os.Stderr, "Ошибка при чтении:", err)
		return
	}
	data := buf.Bytes()
	if len(data) < 1 {
		fmt.Fprintln(os.Stderr, "Нет данных для чтения")
		return
	}
	switch data[0] {
	case 0x01:
		ClientDecode(data)
	case 0x02:
		ServerDecode(data)
	default:
		fmt.Fprintln(os.Stderr, "Неизвестный заголовок")
	}
}
func ClientDecode(data []byte) {
	clientInfo := UnmarshalClientHello(data)
	clientInfoJson, err := json.Marshal(clientInfo)
	if err != nil {
		fmt.Println("Ошибка при кодировании в JSON:", err)
		return
	}
	fmt.Printf(string(clientInfoJson))
}
func ServerDecode(data []byte) {
	server_info := UnmarshalServerResponse(data)
	serverSessionID := server_info.SessionIDHex
	fmt.Printf(string(serverSessionID))
}

Нам понадобятся следующие типы. Структуру для ServerHelloInfo можно было бы и не создавать, так как нам нужен только SessionID / SessionIDHex, а ClientHelloInfo упростить, но как задел на будущее пусть будет.
Массив CipherSuites для функции MakeCipherSuite генерируется парсингом csv из https://www.iana.org/assignments/tls-parameters/tls-parameters-4.csv, пример генерации, как и полный пример реализации разбора можно посмотреть в коде из статьи "Parsing a TLS Client Hello with Go's cryptobyte Package". Здесь же сокращенный вариант разбора под мои нужды:

type ProtocolVersion uint16

func (v ProtocolVersion) Hi() uint8 {
	return uint8(v >> 8)
}

func (v ProtocolVersion) Lo() uint8 {
	return uint8(v)
}

func (v ProtocolVersion) MarshalJSON() ([]byte, error) {
	return json.Marshal([2]uint8{v.Hi(), v.Lo()})
}

type CompressionMethod uint8

func (m CompressionMethod) MarshalJSON() ([]byte, error) {
	return json.Marshal(uint16(m))
}

type CipherSuite struct {
	Code   [2]uint8 `json:"code"`
	Name   string   `json:"name,omitempty"`
	Grease bool     `json:"grease,omitempty"`
}

func (c CipherSuite) CodeUint16() uint16 {
	return (uint16(c.Code[0]) << 8) | uint16(c.Code[1])
}

func MakeCipherSuite(code uint16) CipherSuite {
	hi := uint8(code >> 8)
	lo := uint8(code)

	return CipherSuite{
		Code:   [2]uint8{hi, lo},
		Name:   CipherSuites[code].Name,
		Grease: CipherSuites[code].Grease,
	}
}

type ClientHelloInfo struct {
	Raw []byte `json:"raw"`

	Version            ProtocolVersion     `json:"version"`
	Random             []byte              `json:"random"`
	SessionID          []byte              `json:"session_id"`
	CipherSuites       []CipherSuite       `json:"cipher_suites"`
	CompressionMethods []CompressionMethod `json:"compression_methods"`
	Extensions         []Extension         `json:"extensions"`

	Info struct {
		ServerName     *string  `json:"server_name"`
		SCTs           bool     `json:"scts"`
		Protocols      []string `json:"protocols"`
		JA3String      string   `json:"ja3_string"`
		JA3Fingerprint string   `json:"ja3_fingerprint"`
	} `json:"info"`
}

type ServerHelloInfo struct {
	Raw []byte `json:"raw"`

	Version           ProtocolVersion   `json:"version"`
	Random            []byte            `json:"random"`
	SessionID         []byte            `json:"session_id_string"`
	SessionIDHex      string            `json:"session_id"`
	CipherSuite       CipherSuite       `json:"cipher_suite"`
	CompressionMethod CompressionMethod `json:"compression_method"`
	Extensions        []Extension       `json:"extensions"`

	Info struct {
		SelectedProtocol *string `json:"selected_protocol"`
		SCTs             bool    `json:"scts"`
	} `json:"info"`
}

Собственно, разбор заголовков:

func UnmarshalClientHello(handshakeBytes []byte) *ClientHelloInfo {
	info := &ClientHelloInfo{Raw: handshakeBytes}
	handshakeMessage := cryptobyte.String(handshakeBytes)

	var messageType uint8
	if !handshakeMessage.ReadUint8(&messageType) || messageType != 1 {
		return nil
	}
	var clientHello cryptobyte.String
	if !handshakeMessage.ReadUint24LengthPrefixed(&clientHello) || !handshakeMessage.Empty() {
		return nil
	}

	if !clientHello.ReadUint16((*uint16)(&info.Version)) {
		return nil
	}

	if !clientHello.ReadBytes(&info.Random, 32) {
		return nil
	}

	if !clientHello.ReadUint8LengthPrefixed((*cryptobyte.String)(&info.SessionID)) {
		return nil
	}

	var cipherSuites cryptobyte.String
	if !clientHello.ReadUint16LengthPrefixed(&cipherSuites) {
		return nil
	}
	info.CipherSuites = []CipherSuite{}
	for !cipherSuites.Empty() {
		var suite uint16
		if !cipherSuites.ReadUint16(&suite) {
			return nil
		}
		info.CipherSuites = append(info.CipherSuites, MakeCipherSuite(suite))
	}


	if !clientHello.Empty() {
		return nil
	}

	return info
}

func UnmarshalServerResponse(handshakeBytes []byte) *ServerHelloInfo {
	info := &ServerHelloInfo{Raw: handshakeBytes}
	handshakeMessage := cryptobyte.String(handshakeBytes)

	var messageType uint8
	if !handshakeMessage.ReadUint8(&messageType) || messageType != 2 {
		return nil
	}

	// Пропускаем длину сообщения (3 байта)
	if !handshakeMessage.Skip(3) {
		return nil
	}

	// Чтение версии протокола (2 байта)
	if !handshakeMessage.Skip(2) { // версия обычно пропускается
		return nil
	}

	// Чтение и пропуск случайного числа (32 байта)
	if !handshakeMessage.Skip(32) {
		return nil
	}

	var sessionIDBytes cryptobyte.String
	if !handshakeMessage.ReadUint8LengthPrefixed(&sessionIDBytes) {
		return nil
	}
	info.SessionIDHex = hex.EncodeToString(sessionIDBytes)

	return info
}

Итого, у нас есть каркас приложения, для чтения из пайпа байтов наших заголовков и возврат clientInfoJson и serverSessionID

В Nginx выставляем:
ssl_session_cache none; ssl_session_tickets off; keepalive_timeout 0;
таким образом избавиться от тикетов в сессиях ssl и гарантированно создавать сессию на каждый запрос. В противном случае, с curl все будет работать, а вот скажем тот же Chrome обязательно постучится за favicon и корректное значение Session ID мы не увидим.
Далее остается самая малость - вывести данные из Redis: в нужный нам локейшн нашего http server слушающего по ssl вставляем content_by_lua_block или content_by_lua_file примерно такого содержания:

local function getclientinfo()
    local redis_key = ngx.var.ssl_session_id
    local clientinfo
    local redis_err
    local ok, red = pcall(redis.connect, { host = redis_local_server, port = redis_local_port, timeout = redis_local_connect_timeout })
    if not ok then
        redis_err = true
    end
    if not redis_err then
        local res, err = red:get(redis_key)
        if err then
        elseif not res then
        else
            clientinfo = res
        end
    end

    local jsonData = json.decode(clientinfo)
    ngx.header.content_type = 'application/json; charset=utf-8'
    ngx.say(jsonData)
    ngx.exit(200)

end

getclientinfo()

Если не нужен полный вывод - используем ngx.say(jsonData.cipher_suites)

Собственно вот и все. Постарался объяснить основные моменты и показать пути. Код писался на скорую руку и нуждается в допиливании - решение эскизное. Но при ресерче на просторах интернета, за исключением статьи Andrew Ayer, попадалось много вопросов и мало хоть сколько-нибудь систематизированного / полезного. Надеюсь, это кому-то поможет лишний раз не тратить время.