dxdt.ru: занимательный интернет-журнал

Очередная атака “про Spectre”, позволяющая, в частности, читать память произвольных процессов в Linux, и на Intel, и на AMD. Пусть в этот раз речь в публикации не про новые аппаратные особенности, а про исправления в старых особенностях, но я всё же сошлюсь на свою записку о неустранимости подобных дефектов аппаратуры.

(Подробная статья на OpenNET.)

В массовом TLS для веба криптосистемы с постквантовой стойкостью уже имеются, но есть ещё немало направлений, где такие криптосистемы нужны (если учитывать “угрозу квантовых компьютеров”, конечно). И во многих случаях требуются не криптосистемы согласования симметричного секрета, как в случае внедрения ML-KEM для TLS, а криптосистемы подписи. Можно, например, посмотреть в сторону DNS и DNSSEC, пусть последняя и не очень-то распространена, но там требуется именно электронная подпись. В DNS всегда приветствовались короткие пакеты данных, без излишнего раздутия. В предлагаемых сейчас постквантовых криптосистемах, традиционно, ключи и/или подписи – очень большие. Как это будет упаковываться в DNS – пока что не очень понятно: десять, предположим, килобайт на подписи с ключами – для DNS это слишком много.

Вообще, уже из распространённого предположения, что симметричные шифры сохраняют достаточную стойкость перед “квантовыми атаками”, можно сделать вывод, что возможны и короткие подписи, – то есть, что-то асимметричное, – главное, чтобы такие криптосистемы оказались ещё и эффективными: проверка 256-битной подписи, занимающая один час, тоже не особенно хороший вариант.

Длины ключей/подписей в текущем состоянии постквантовой криптографии и “квантовых вычислений” тема довольно странная: с одной стороны, как оно могло бы преобразовываться на “квантовом компьютере” не ясно, но если исходить из того, что для RSA нужна тысяча “квантовых элементов” компьютера на один бит ключа, то и для RSA можно просто добавить несколько килобит, получив практическую постквантовую стойкость – в конце концов, стойкость к обычным атакам для RSA развивалась именно так: 512-битный ключ сейчас можно факторизовать достаточно быстро для того, чтобы практическую разрядность передвинули к 2048 битам. С другой стороны, нет никаких гарантий того, что для задач, лежащих в основе уже стандартизованных постквантовых систем, тоже не найдут эффективных квантовых алгоритмов.

Поэтому, кстати, довольно странно читать в популярных статьях и новостных сообщениях по этой теме, что “сложность решения задач не отличается для обычных и квантовых компьютеров”. Ведь вовсе и не предполагается, что квантовые компьютеры что-то там вычисляют, так что вообще странно сравнивать сложность для “обычных и квантовых” компьютеров, поскольку там разные модели. При этом: и для классических атак (на “обычном компьютере”) на постквантовые криптосистемы возможны улучшения, и всякий квантовый алгоритм можно выполнить на классическом компьютере, и ту же задачу факторизации “нетрудно” очень быстро решать для произвольных больших чисел, если только вычислитель обладает быстрой памятью в объёме факториала от обрабатываемого числа (“небольшая” особенность, да).

Естественно, длина ключей постквантовых подписей диктуется и скоростью работы на практических компьютерах, и требованиями стойкости к атакам на этих практических классических компьютерах: улучшат такие атаки – разрядность (в том или ином виде) придётся увеличивать, вне зависимости от того, появились уже подходящие квантовые компьютеры или нет (собственно, посмотрите на тот же ML-KEM – бывший Kyber, – там уже сейчас несколько вариантов с разной классической стойкостью).

Но вернёмся к DNS и TLS. Можно предположить, что если “огромные постквантовые ключи” в данную систему не влезут, а уменьшить длину ключей не получится, то, скорее всего, из этого выйдет лишь ещё одна причина для повсеместного перехода на очередной вариант “DNS-over-TLS”: мол, там постквантовая стойкость уже есть, а то, что задача решается совсем другая – аутентификация узлов, а не защита подлинности данных, – ну так придётся как-то скорректировать модель угроз и привыкать “к новым подходам”. Впрочем, возможны и какие-то не использующие TLS, но существенно более интерактивные, варианты на замену DNS, поскольку именно интерактивность позволяет встроить более компактные схемы проверки подлинности данных. Речь тут про схемы, когда и конкретный запрос формируется с учётом некоторого ключа, и ответ приходит – тоже с учётом состава сессионных ключей из запроса и долгих ключей “из DNSSEC”. Возможны, скажем, варианты алгоритма Диффи-Хеллмана (постквантового, конечно). Поэтому, если темпы внедрения постквантовой криптографии не ослабеют, то можно ожидать новой, “интерактивной DNS”.

Занятная работа, удивительным образом не укладывающаяся в мейнстрим “про ИИ” и показывающая на конкретной статистике и конкретных примерах, что ИИ-LLM не “рассуждают”, а лишь генерируют текст, даже “решая” задачки начальной школы: GSM-Symbolic: Understanding the Limitations of Mathematical Reasoning in Large Language Models.

Так, если исследователями в текст задачи добавляется не влияющее на “арифметический результат”, но относящееся к предмету задачи, уточнение, то LLM начинают интерпретировать слова из этого уточнения и встраивать интерпретацию в “решение”, что приводит к неверному ответу, который сопровождается абсурдными рассуждениями (см. пример ниже). То есть, LLM не “рассуждают”, а подбирают токены, генерируя вероятностным способом слова и тексты. Оптимизация перебора приводит к тому, что часто тексты похожи на решения задач, записи которых даны в качестве начального состояния. Отлично выраженный отрицательный эффект (то есть, неверные решения) обнаруживается и при замене чисел и имён собственных в формулировках задач из эталонной выборки.

Вроде, это всё и так понятно, но наука сейчас такова, что более или менее строгое изложение, конечно, полезно в этом странном случае. Особенно, на фоне типичных для данной области восторженных реляций.

Пример из работы (всё в переводе с английского):

Предлагаемая задача (“сбивающее” добавление выделено):
Оливер собрал 44 киви в пятницу. Затем он сорбрал 58 киви в субботу. В воскресенье он собрал в два раза больше киви, чем в пятницу, но пять из них были немного меньше среднего. Сколько киви у Оливера?

Ответ с “объяснениями” LLM o1-mini:
Оливер собирал киви в течение трёх дней следующим образом:
– пятница: 44 киви;
– суббота: 58 киви;
– воскресенье: в два раза больше, чем он собрал в пятницу, то есть 2*44 = 88 киви.
Однако, в воскресенье 5 из этих киви были меньше среднего. Мы должны вычесть их из общего количества для воскресенья: 88 (киви в воскресенье) – 5 (мелкие киви) = 83 киви. Теперь, суммируя киви за все три дня: 44 (пятница) + 58 (суббота) + 83 (воскресенье) = 185 киви. У Оливера всего 185 киви.

Кстати, я недавно приводил в пример сходную по принципам построения задачу “про Сироба” для GigaChat, но в той задаче ещё использован эффект невозможности “обращения” токенов в буквы (обычно, выражется в том, что LLM-система не способна переставить буквы в слове).

(Новостная статья на ArsTechnica.)

Криптосистемы с постквантовой стойкостью предлагается внедрять в составе гибридных схем. Именно так сделано в TLS и в браузерах: широко и давно используемая X25519 + постквантовая криптосистема Kyber, на случай, если последняя окажется нестойкой. Под “гибридной” схемой здесь подразумевается объединение секретов, независимо полученных применением одной и второй криптосистемы: ни о каком “подмешивании” шагов одной криптосистемы в другую речи нет – X25519 не влияет на стойкость Kyber и наоборот (формальная оценка стойкости гибридной схемы в целом и для разных моделей – несколько другая история, но эти детали тут не важны). Подобная “гибридизация” имеет ряд занимательных особенностей: так, постквантовая Kyber должна, очевидно, обладать и стойкостью к классическим атакам, а это означает, что она некоторым образом усиливает защиту сессий с точки зрения переспективных атак “неквантовыми методами”.

То есть, данные криптосистемы достаточно различаются математически, чтобы даже универсальная атака на X25519 не сломала, гарантированно, и Kyber. Так что, если через десять лет вариант протокола Диффи-Хеллмана (ECDH), реализуемый X25519, научатся быстро ломать, – например, для конкретных параметров, – то записанный трафик всё равно будет защищён Kyber. Естественно, это всего лишь обращение мотивации для использования X25519 вместе с Kyber, чтобы подстраховаться на случай внезапного обнаружения неустранимых дефектов в последней. Обратная схема тоже работает, но X25519 используется дольше и, возможно, лучше изучена, так что “поломка” Kyber, конечно, выглядит более вероятным событием.

Вообще, из того, что Kyber признана криптосистемой с постквантовой стойкостью и стандартизована как ML-KEM, вовсе не следует, что доказано отсутствие квантовых алгоритмов взлома Kyber; уж тем более неверно будет утверждать, что эффективность решения базовой задачи для Kyber не отличается на обычных и квантовых компьютерах. Во-первых, квантовых компьютеров пока что нет, и непонятно, как они вообще могли бы быть устроены, чтобы ломать Kyber. Во-вторых, квантовые компьютеры сами ничего “не вычисляют” в том смысле, чтобы сравнивать с “обычными” (но всякий квантовый алгоритм можно запустить и выполнить на “обычном компьютере” – времени потребуется несравнимо больше, чем хотелось бы для достижения практической полезности). В-третьих, доказывать отсутствие алгоритмов вообще непросто. Так что в случае с постквантовой стойкостью слишком многое сводится к алгоритму Шора, в его самой теоретической интерпретации, а для ML-KEM/Kyber резонно ожидать и квантовых улучшений атак тоже.

Более того, поскольку одна задача (Kyber) не переводится быстро в другую (ECDH), то можно предположить не только появление специального квантового алгоритма для эффективного взлома Kyber, но и то, что квантовый компьютер, реализующий этот алгоритм, окажется (согласно некоторой теории) построить проще, чем не менее квантовый компьютер для алгоритма Шора. А что? Теоретические аналоговые вычислители они на то и теоретические, и аналоговые, что это сейчас только различные оценки количества “квантовых элементов” для практической атаки на RSA расходятся на несколько десятичных порядков, а на следующем шаге – могут разойтись и оценки достижимости по новым и старым алгоритмам.

Продолжаем тему “про алгоритмы“, на примере циклов и компиляторов. Запись алгоритма на языке высокого уровня (ЯВУ) – это некоторый пересказ того, что должно выполняться вычислителем. На то он и язык высокого уровня. При этом, обычно, вычислителем исполняется не запись на ЯВУ, а некоторый результат преобразования компилятором. То есть, алгоритм, казалось бы, один. Но, во-первых, может быть много разных записей этого алгоритма на многих разных языках. Даже если удалось удачно определить, что означает фраза “две программы реализуют один алгоритм” (отдельная проблема), то, при минимально содержательном определении, машинное доказательство того, что разные записи соответствуют одному алгоритму – составит большую трудность (в общем виде соответствующее сравнение вообще неразрешимо, но это другая история, а несложные конечные автоматы, обычно, как-то эффективно сравнить всё же можно). Трудности на этом направлении гарантируют, что даже если реализован некий автоматический перевод с одного ЯВУ на другой, это вовсе и не означает, что результат не менее автоматического анализа переведённой программы применим к программе исходной.

Другими словами, если у вас есть добротный анализатор для языка Fortran (для языка, не для алгоритмов), то он вовсе не обязательно эффективен для программ на Haskell, которые транслированы (ну, предположим) в код на Fortran: проверяться всё равно будет Fortran-программа. Это сильно сужает возможности по созданию полезных универсальных “анализаторов кода на ЯВУ”.

Во-вторых, на практике записи алгоритма обрабатывают разные компиляторы, которые переводят его в разный машинный код для разных вычислителей – то есть, для разной аппаратуры. Можно ли тут что-то вообще доказывать о программе, выбросив из рассмотрения компилятор и аппаратуру? Вряд ли. Вообще, а если две реализации некоторого алгоритма дают одинаковый вывод на эталонном наборе входных данных, то означает ли это, что и в рамках реализации записан один и тот же алгоритм? Не обязательно, но степень соответствия действительности кодирования тут сильно зависит от строгости определений.

Предположим, что на процессоре “Имярек-7” команда MOV (“копирующая/перемещающая какие-то данные”) не просто сама по себе Тьюринг-полная (как в x86), но ещё и содержит “особенность” реализации, приводящую к тому, что число 0xFFFFFFFF превращается в 0x0, если сделать два MOV подряд из ОЗУ в регистр REG1. Поэтому, чтобы какие-то детали гарантировать относительно программы и реализации алгоритма, нужно в рассмотрение включить и аппаратные особенности. Сделать это автоматическим способом непросто. Отчасти поэтому-то и появляются всякие разные трансляции в “байт-код”, пригодный для исполнения “песочницей” (например, “Java-машиной”, если хотите): в такой конфигурации можно построить какие-то формальные описания и для языка, и для “машины”, которая его интерпретирует. Можно показать, что тут, при следовании некоторым принципам, всё разрабатывается безопасно (и это, действительно, так, но далеко не в общем случае).

Если же что-то всё же пошло не так, то оно пошло из-за дефекта реализации “машины”, а эта реализация находится за пределами модели. Это удобное сужение темы: если у вас код вылезает из песочницы, то проблема существует над песочницей, а не в ней; песочница хороша по определению: существовала бы проблема в ней – вылезать и не требовалось бы, да.

Представьте, что сложную схему отношений между записями алгоритмов, разными языками высокого уровня, компиляторами и аппаратурой зарисовали в виде графа, где направленные рёбра – это стрелки, обозначающие преобразование кода. Например, перевод с одного ЯВУ на другой. Или перевод в машинный код. Или перевод в подмножество состояний конечного автомата, соответствующего процессору. Тут за каждой стрелкой скрываются целые наборы “схлопывающих” и забывающих отображений, при которых различные способы представлений на стороне начального узла все переводятся в единственный способ на стороне узла конечного (такое вот “ядро” отображения). Например, циклы for, while, do – все схлопываются в сочетание операторов if, потому что только так позволяет записывать целевой язык. Тогда базовые логические преобразования, записываемые формально, могут и совпадать, но вот большое количество возможностей по внесению особенностей и ошибок в исходный код – останется вне пределов доступности для того или иного анализатора, схлопнувшись, что называется, до неразличимости.

Иногда при отладке программ требуется просматривать трафик, защищённый TLS. Распространённый случай – HTTPS. Чтобы просматривать содержание TLS-трафика при помощи анализаторов протоколов (Wireshark) нужны сессионные ключи. В этой записке посмотрим, с примерами кода, как экспортировать эти ключи, если используется типовая библиотека Go crypto/tls.

Принцип довольно простой: при установлении TLS-соединения библиотека будет выводить сеансовые симметричные секреты и сопроводительный параметр (поле Random) в заданный файл, который позже использует Wireshark (или tshark, как в примерах ниже) для раскрытия трафика. Чтобы это заработало в Go, достаточно в структуре конфигурации TLS-клиента (или TLS-сервера) указать (KeyLogWriter) имя интерфейса для записи в файл (writer в терминологии Go), а сам интерфейс предварительно создать и направить вывод в нужный файл. А именно (ниже будет рабочий пример кода; здесь – фрагмент):

SessionKeysFile, err := os.OpenFile("s-keys.txt", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil {
[...]
}
[...]
TLSConfig.KeyLogWriter = SessionKeysFile

Так сконфигурированный экземпляр TLS-соединения (в смысле кода Go) будет писать в заданный файл s-keys.txt сведения о ключах, в текстовом формате. Сам формат очень простой, но отличается для TLS 1.3 и других версий (см. ниже). Полный пример работающего кода для TLS-клиента (логика кода экспорта ключей для сервера – не отличается):

package main

import (
	"fmt"
	"net"
	"time"
	"crypto/tls"
	"os"
)

func main(){
	var TLSConfig tls.Config
	SessionKeysFile, err := os.OpenFile("s-keys.txt", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
	if err != nil {
		fmt.Printf("File error: %s\n", err.Error())
		os.Exit(1) 
	}
	hostname := "example.com"

	TLSConfig.KeyLogWriter = SessionKeysFile
	TLSConfig.MinVersion = tls.VersionTLS13
	TLSConfig.MaxVersion = tls.VersionTLS13
	TLSConfig.RootCAs = nil
	TLSConfig.InsecureSkipVerify = true

	timeout := 3 * time.Second
	TCPConn, err := net.DialTimeout("tcp", hostname + ":443", timeout)
	if err != nil {
		fmt.Printf("Connection error: %s\n", err.Error())
		os.Exit(1)
	}

	TCPConn.SetReadDeadline(time.Now().Add(timeout))
	TCPConn.SetWriteDeadline(time.Now().Add(timeout))

	TLSConn := tls.Client(TCPConn, &TLSConfig)

	HTTPGet := "GET / HTTP/1.1\r\nHost: " + 
				hostname + "\r\n" + 
				"Connection: close\r\n" +
				"User-Agent: TLS-keys-dump" + 
				"\r\n\r\n"
				
	_, err = TLSConn.Write([]byte(HTTPGet))
	if err != nil {
		fmt.Printf("Connection (TLS) write error: %s\n", err.Error())
		TLSConn.Close()
		os.Exit(1)
	}
	TLSConn.Close()
	os.Exit(0)
}

Используя привычные многим tcpdump и tshark нетрудно посмотреть, что получилось. В tshark файл с сессионными секретами передаётся при помощи опции tls.keylog_file (в Wireshark – можно загрузить через интерфейс редактирования параметров TLS-парсера). Вызов tshark:

$ tshark -r dump-ens.pcap -o tls.keylog_file:tls-export-keys/s-keys.txt -O tls -S "-----PACKET-----" -x

Здесь: dump-ens.pcap – дамп трафика, записанный tcpdump; s-keys.txt – файл, в который экспортированы TLS-секреты.
Фрагмент результата работы:

Decrypted TLS (83 bytes):
0000  47 45 54 20 2f 20 48 54 54 50 2f 31 2e 31 0d 0a   GET / HTTP/1.1..
0010  48 6f 73 74 3a 20 65 78 61 6d 70 6c 65 2e 63 6f   Host: example.co
0020  6d 0d 0a 43 6f 6e 6e 65 63 74 69 6f 6e 3a 20 63   m..Connection: c
0030  6c 6f 73 65 0d 0a 55 73 65 72 2d 41 67 65 6e 74   lose..User-Agent
0040  3a 20 54 4c 53 2d 6b 65 79 73 2d 64 75 6d 70 0d   : TLS-keys-dump.
0050  0a 0d 0a

Обратите, кстати, внимание на то, что в TLS 1.3 без секретных ключей сессии не удалось бы посмотреть даже серверные сертификаты. Так что, вообще говоря, для того, чтобы убедится в работоспособности метода, можно было бы даже и не отправлять GET-запрос HTTP, как написано в коде выше: для минимальной проверки в TLS 1.3 достаточно сразу разорвать TLS-соединение, при этом факт успешной записи части сессионных ключей в файл отразится в том, что tshark смог разобрать TLS-сертификаты, присланные сервером. Другое дело, что в TLS 1.3 для зашифрования сертификатов используются другие ключи, не те, что для защиты трафика (см. ниже).

Почему это работает? Прежде всего потому, что в TLS для защиты трафика в рамках сессии используются симметричные шифры и, соответственно, симметричный набор секретов для получения не менее симметричных секретных ключей. Так что для расшифрования не нужно получать “ключи сервера” или “ключи от сертификата сервера”. Симметричных ключей используется пара: один для отправки данных, второй – для получения (на клиенте и сервере эти ключи меняются местами). Соответственно, если анализатор трафика знает симметричные ключи, то он может расшифровать записанный трафик. Посмотрим, какой формат у файла с экспортированными ключами. Для TLS 1.3:

CLIENT_HANDSHAKE_TRAFFIC_SECRET [%RANDOM%] [%SECRET%]
SERVER_HANDSHAKE_TRAFFIC_SECRET [%RANDOM%] [%SECRET%]
CLIENT_TRAFFIC_SECRET_0 [%RANDOM%] [%SECRET%]
SERVER_TRAFFIC_SECRET_0 [%RANDOM%] [%SECRET%]

Чтобы не перегружать текст шестнадцатеричными цифрами я заменил поля, содержащие соответствующие данные, на понятные имена: [%RANDOM%] и [%SECRET%]. В исходном файле, очевидно, на месте этих обозначений будут длинные наборы шестнадцатеричных цифр.

В поле с именем [%RANDOM%] записывается значение из поля Random начального сообщения ClientHello. Это может показаться загадочным, если вы не сталкивались с TLS ранее, однако тут данное значение нужно лишь для того, чтобы анализатор протокола мог быстро сопоставить конкретный секрет и конкретную TLS-сессию в записанном трафике: то есть, в данном случае, это всего лишь метка. Сам секрет, позволяющий получить ключи для шифров, указывается в поле [%SECRET%]. (Ключи вычисляются на основе данного секрета при помощи соответствующей функции HKDF.)

В файле указаны клиентские и серверные секреты для разных этапов соединения TLS 1.3. CLIENT(SERVER)_HANDSHAKE_TRAFFIC_SECRET – это ключи для защиты начальных сообщений. CLIENT(SERVER)_TRAFFIC_SECRET_0 – это ключи первого поколения для защиты трафика. В TLS 1.3 возможно обновление ключей в рамках сессии, то есть, могли бы быть и TRAFFIC_SECRET_n следующих поколений, но это тема для другой записки. Формат файла подразумевает и другие поля, которые тоже тут не рассматриваются – все они устроены так же, но сдержат секреты других типов, которые могут появиться в ходе соединения TLS 1.3, так что анализаторы трафика должны обрабатывать их автоматически.

Для TLS 1.2 файл с экспортируемыми секретами, генерируемый библиотекой Go, будет будет использовать другой формат:

CLIENT_RANDOM [%RANDOM%] [%SECRET%]

Это обусловлено тем, что в TLS 1.2 используется другая схема получения сессионных ключей, в ней нет таких этапов, как в TLS 1.3, а защита трафика включается позже.

***

Некоторые другие записки по этой же теме:

TLS для DevOps
Секретные ключи в трафике и симметричные шифры
TLS в виртуальных машинах и извлечение ключей хостингом

Технические детали устройства TLS – можно узнать в техническом описании.

Интересный практический пример неверной настройки DNS в зоне vk.com, как его можно видеть и сейчас, и уже в течение нескольких недель. Скриншот выдачи сервиса проверки audit.statdom.ru (подробные объяснения – ниже):

Зона vk.com делегирована на авторитативные NS с именами, находящимися в той же зоне (так называемые “субординатные” NS), а именно: ns1, ns2, ns3, ns4.vk.com (всё в vk.com, не лучшее решение, но сейчас о другом). При этом в самой зоне vk.com для имён NS указаны AAAA-записи – это DNS-записи, содержащие IPv6-адреса. Вообще, чтобы избежать циклов при рекурсивном опросе DNS, для имён авторитативных серверов, которые сами определены в делегируемой зоне, используются так называемые glue-записи: серверы имён вышестоящей зоны возвращают IP-адреса для имён, на которые эта зона делегирована.

То есть, если домен example.com делегирован на ns1.example.com и ns2.example.com, то авторитативные серверы зоны первого уровня com. будут возвращать в дополнительном блоке DNS-ответа IP-адреса для ns1.example.com и ns2.example.com, чтобы резолвер мог к ним обратиться. (Понятно, что иначе резолвер, для определения адреса ns1.example.com, должен обратиться к DNS-серверам example.com, а чтобы обратиться к DNS-серверам example.com – нужно узнать адрес ns1.example.com, ну и так далее.)

Так вот, для vk.com в glue- указаны только А-записи (IPv4-адреса), но не указаны AAAA-записи (IPv6-адреса). Между тем, как отмечено в предыдущем параграфе, в самой зоне IPv6-адреса для NS указаны: каждый NS из списка делегирования снабжён v6-адресом в DNS. Под “данными в самой зоне” тут имеются в виду данные, возвращаемые непосредственно авторитативными NSами (которые ns[1,2,3,4].vk.com).

Вообще говоря, делегирующие ответы – и, тем более, glue-записи – имеют ключевое значение на базовой стадии рекурсивного опроса, но состав записей для NS в самой зоне может быть другим, при условии, что сведения, полученные с серверов уровнем выше, в этот состав вкладываются. То есть, можно допустить, что в самой зоне указаны дополнительные NS, которых нет в списке делегирования (обратная ситуация свидетельствует об очень грубой ошибке и представляет собой угрозу).

Для vk.com дополнительными оказываются адреса IPv6 для авторитативных NS. Адреса выбраны красивые, резолверы, работающие по v6, могли бы их использовать, но DNS-сервис под ними недоступен и отсутствуют glue-записи.

Цитата из заметки, вышедшей на dxdt.ru в 2014 году (собственно, это почти вся та заметка):

Например, очки дополненной реальности осуществляют обработку данных в “облачном сервисе” (пусть это будет сервис Google), это означает, что изображение того или иного объекта реальности, построенное видеокамерой очков, воздействует на информационную систему сервиса. Другими словами, показав носителю очков определённое изображение, можно внедрить программный код во вполне себе виртуальный сервис Google, хоть это и похоже на фантастику. Внедрённый код сможет распространиться по другим узлам, образующим “виртуальность”, а также проникнуть в другие очки, например. Или в смартфоны. Сервис-носитель, конечно, должен содержать подходящую уязвимость, но кого сейчас удивишь очередным “переполнением буфера”?

Гибридная криптосистема с постквантовой стойкостью X25519Kyber768 использует, как нетрудно догадаться, ключи X25519 в дополнение к Kyber. При этом X25519 – типовая криптосистема в современном TLS, так что в одном и том же ClientHello может быть одновременно два ключа: и X25519Kyber768, и просто X25519. И вот, например, Firefox в свежих версиях использует тут один и тот же ключ X25519 – и в гибриде, и в обособленном варианте. Это экономит одну итерацию X25519 (технически, что в гибридном варианте, что нет – это одна и та же криптосистема, никаких отличий). А вот Chrome, в такой же ситуации, использует два разных ключа X25519.

В работе LLM (Large Language Models) используются токены, а не слова, как слова. То есть, процесс можно сравнить с изучением письменности, но без изучения языка. Для использования компьютерами, буквы, как символы, кодируются значениями байтов – это вполне привычная система.

Так, если взять ASCII, то символу (букве) L соответствует шестнадцатеричный индекс 0x4C. Тут есть множество философских моментов: во-первых, натуральное число 0x4C – это число, а не буква, так что, в большинстве компьютерных применений, 0x4C – вовсе не имеет отношения к букве L; во-вторых, для того, чтобы число указало на букву, всегда требуется внешняя структура – ASCII, в данном случае, – и система соглашений, определяющая, как минимум, метаязык и алфавит; в-третьих, компьютер, на котором работает LLM, “читает” именно байты, а не воспринимает буквы как буквы, то есть, как элементы, переключающие неизвестную компьютеру структуру, хоть бы это была и только таблица ASCII (тем более, что современные тексты используют Unicode – другое кодирование).

Числа, записанные в байтах, могут “быть буквами”, но могут и не быть. Буквы могут “быть звуками”, а могут и не быть. Хитрость в том, что сама по себе, без дополнительных соглашений, буква L никакой звук не обозначает, а обозначает, скажем, “длину стороны треугольника”, однако L может использоваться в записи звуков. (Да, речь только про фонетическое письмо.) Тут не так важно то, насколько фонетика вообще определяет язык, как то, что превращения букв при записи слов языка определяются, в том числе, превращениями звуков. Так что именно этот момент, – поднятие фонетической структуры из разных записей, – позволяет изучать происхождение и родство современных языков. Это максимально далеко и от ASCII, и от Unicode, самих по себе.

Слово “яблоко” не является яблоком, но “слово” является словом (или тоже нет?), однако ещё дальше от смысловых конструкций ASCII- или Unicode-таблицы, преобразованные в очередные наборы чисел. Всё это не мешает попыткам переносить следы способов записи смысловых конструкций, оставшиеся в корпусе обучающих текстов, в новый поток индексов (байтов), генерируемый LLM. И эти индексы пользователю предлагается считать буквами, потому что компьютером же можно преобразовать коды в изображения символов, которые пользователь начнёт читать как текст. “Большая” же идея, естественно, в предположении о том, что автоматический компьютерный перебор может воссоздать ту самую, внешнюю структуру.

Известно, что идея LLM выросла из методов атрибуции текстов: разным авторам свойственны разные словари (конкордансы) и стили комбинирования слов, связанные с привычной записью частей речи; если на основе текстов с известным авторством построить достаточно длинные “вероятностные цепочки” слов и их частей (последнее – необходимо для учёта морфологических особенностей), то можно будет строить предположения об авторстве для других текстов, сравнивая их цепочки с цепочками из базовой выборки. Это можно делать даже вручную, но компьютерная обработка несравнимо эффективнее. Переход к LLM начинается со следующего шага, на котором уже слова из словаря выбираются так, чтобы подходить к цепочкам, построенным на большой выборке текстов. Свидетельствует ли успешное исполнение сверхмощным компьютером перевернутого алгоритма атрибуции о каком-то “универсальном интеллекте”? Вряд ли.

Использование имеющихся сейчас посквантовых криптосистем в TLS существенно увеличивает объём передаваемых данных. Например, ключ Kyber768, используемый в первом же сообщении (ClientHello), требует более килобайта (1184 байта). При этом, в TLS 1.3 есть штатная возможность передать несколько ключей для разных криптосистем в одном сообщении ClientHello, чтобы сервер выбрал подходящее. Эта возможность постоянно используется на практике.

Например, клиент может сразу передать ключи X25519 (32 байта) и P-256 (32+32 == 64 байта). То есть, две криптосистемы – и лишь 96 байтов расходуется на запись ключей (небольшое количество дополнительных байтов нужно для записи тех структур, в которых передаются ключи, но это можно не учитывать). Если передавать ключи двух постквантовых криптосистем, – скажем, с теми же Kyber768 и стандартизованным вариантом ML-KEM, – то получается уже больше двух килобайт. Это много, но если регулярно переходить от одной поствкантовой криптосистемы к другой, то становится необходимым, рутинным элементом TLS-соединений. Заметьте, что сам перечень поддерживаемых клиентом криптосистем для обмена сессионными секретами передаётся в TLS отдельно. Обычно, в этом перечне указано значительно больше криптосистем, чем передано ключей. Так, браузер может передавать семь поддерживаемых вариантов и ключи только для трёх из них (так сейчас делает Firefox). Чтобы сервер мог выбрать криптосистему, ключи от которой отсутствуют в ClientHello, в TLS 1.3 предусмотрен механизм повторного согласования – HelloRetryRequest: сервер, в этом случае, запрашивает повторное ClientHello, где будет только ключ той криптосистемы, которая выбрана (это всё можно самостоятельно увидеть на тестовом сервере TLS 1.3 при помощи современного браузера).

Подобный перебор с постквантовыми криптосистемами ещё больше увеличивает трафик, поэтому уже рассматриваются варианты того, как бы данный момент переложить на DNS. Так, в сообщении Google про ML-KEM в браузере Chrome, на которое я недавно ссылался, упоминается соответствующий черновик RFC – там предлагается публиковать в DNS сведения о предпочитаемых криптосистемах для обмена сеансовыми ключами в TLS. Конечно, тут нужно учитывать возможную защиту DNS-ответов от подмены, то есть, всё это тянет за собой не только и не столько DNSSEC (которая сама не имеет пока что ничего “постквантового”), как DNS-over-TLS/DNS-over-HTTPS.

Развитие постквантового TLS очень бурное. Впрочем, пока что не совсем понятно, для чего вообще такой рост объёмов данных. Сама по себе “постквантовая стойкость” тут ничего не объясняет, как и популярные описания в стиле “зашифруй заранее, пока нет квантового компьютера”. Однако вот уже и DNS охвачена дополнением записей. С одной стороны, размещение предварительных сведений о настройках TLS в DNS выглядит более чем разумно: запрос в систему всё равно необходим для получения IP-адреса; с другой стороны – данное направление развития как-то быстро сводится к надстраиванию новых и новых, всё больших и больших “дополнений”. (Надстраивание происходит в ускоряющемся темпе: не успели год назад внедрить в браузеры Kyber, как его уже переименовали в ML-KEM и переделали.) Эти “дополнения” вытесняют привычную работу с DNS, заменяя её на другой процесс, который следует называть “обнаружением сервисов” (Service Discovery) – дело в том, что с появлением ECH даже и IP-адреса будут извлекаться из доступной сети по-другому.