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

Массовый централизованный сервис для обмена сообщениями должен обеспечить собственную надёжность и иметь возможности по восстановлению. Уже эти моменты гарантируют, что с пользовательскими сообщениями, сохраняемыми внутри сервиса, ситуация будет не самой прямолинейной, поэтому рассуждать об удалении переписки по команде пользователя – несколько странно. Посмотрим подробнее на разные особенности “хранения сообщений”.

Так, сообщения сохраняются в какой-то, условно, “базе данных”, потому что речь про централизованный сервис. База может быть распределённой или нет, это тут не особенно важно, потому что “распределение” всё равно происходит внутри единого сервиса (по условию задачи). Работа с базой данных может быть реализована при помощи той или иной распространённой СУБД, либо каким-то собственным решением; да, от хорошо спроектированного сервиса – можно было бы ожидать собственного специализированного решения. Однако тип решения для управления базой данных тут тоже не важен, поскольку так или иначе должны быть и “холодные” резервные копии, и реплики, работающие онлайн, последние, как минимум, необходимы для балансировки между дата-центрами и для обработки локальных отказов. И резервная копия, и реплика – содержат сообщения пользователей в некоторых файлах, выгружаемых на “диски” (то есть, в систему хранения данных). Если эти файлы куда-то утекают, то, понятно, из них можно восстановить сообщения. Кто-то сделал дамп дисков системы хранения данных (или, условно говоря, просто вынул пару дисков и унёс, потому что “так можно было”)? У этого “кого-то” теперь есть все сообщения.

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

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

Другой, менее очевидный, вариант: разнообразные логи – общие системные, а также логи конкретных программных сервисов. В лог-файлы записывается самая разнообразная информация. Там могут быть и пароли пользователей, в том числе, в открытом виде (известная история из практики Facebook); могут быть ключи/пароли, защищающие резервные копии; могут быть реквизиты доступа к базам данных и много всего другого, вплоть до самих текстов сообщений, передаваемых мессенджером. Логи (лог-файлы) передаются через вычислительную сеть – это самое обычное дело: в “операционной практике” принято логи собирать на центральных лог-коллекторах, которые являются отдельными физическими серверами. Более того, типовая практика подразумевает использование логов в системах обнаружения вторжений (или “обнаружения утечек/угроз”, SIEM и т.д., и т.п., там море аббревиатур и терминов, так что называть можно по-разному, но часто наличие такой системы – ни много ни мало, а строгое требование политики ИБ). А чтобы логи так использовать, их нужно скопировать в соответствующую систему. Понятно, что делаются и резервные копии логов, а сами лог-записи, – возможно, превращённые в какие-то типовые “сообщения о событиях”, – записываются в ту или иную дополнительную БД (“от SIEM в SOC”). У этой БД есть реплика, резервные копии, ну и так далее.

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

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

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

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

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

Метаинформация о TLS-соединении. TLS-клиенты часто могут быть классифицированы (с точностью до типа и, реже, версии) по начальному сообщению TLS-сессии. Это позволяет при пассивном прослушивании узнавать трафик конкретных программ-клиентов (и не только, но сейчас речь только про клиентов и начало соединения).

Дело в том, что начальное сообщение, отправляемое клиентом, – ClientHello, – содержит много параметров и, соответственно, имеет структуру, которой хватает для эффективного построения отпечатков. Например, весьма подробное представление о том, как такой классификатор действует, можно составить, если внимательно посмотреть на выдачу моего тестового сервера TLS 1.3. Посмотреть можно непосредственно веб-браузером. При успешном соединении сервер вернёт страницу, где в подробностях показано то самое CLientHello, которое сервер получил от клиента. Вы можете подключиться браузером, обновить страницу несколько раз и увидеть, какие блоки данных не изменяются и, поэтому, служат основой для построения сигнатур.

Посмотрим на ситуацию чуть подробнее (рассматриваем случай TLS поверх TCP). Основу для построения сигнатур (отпечатков) может составлять последовательность байтов, которые представляют структуру TLS-сообщений. То есть, сообщения строятся из некоторого набора полей, а этим полям обязательно соответствуют конкретные заголовки.

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

Эта же идея важна и для разбора самого сообщения ClientHello, где она позволяет анализировать структуру следующего уровня, так как ClientHello вложено в TLS-запись. А состоит идея в том, что значения байтов, кодирующих предполагаемую длину, интерпретируются как смещение; полученное значение прибавляется к текущему адресу (в предварительно собранном потоке байтов) и значения байтов по вычисленному адресу сравниваются с ожидаемыми значениями, которые там оказались бы, если это действительно анализируется ClientHello. И если TLS-записи тут не добавляют много нового (они просто следуют одна за одной), то в ClientHello появляются вложенные поля данных (расширения) и более богатая структура, которая, тем не менее, устроена точно так же: значения байтов, интерпретируемые как целое число, задающее длину, должны строго сходиться, когда рассматриваются в виде цепочки. Заметьте, что до разбора самих значений полей данных дело ещё даже не дошло. Это важная особенность TLS: данный протокол не обладает скрытностью. Скрытный протокол выглядел бы случайным набором байтов со случайными же значениями. TLS, – особенно, на начальном этапе соединения, – выглядит как связанная строгими параметрами длины и типов байтовая структура (так, впрочем, и должно быть).

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

Итак, вернёмся к ClientHello. Помимо верхнеуровневой структуры из вложенных блоков, есть и содержание этих блоков. Например, сообщение ClientHello, в самом начале, после указания версии, полей Random и SessionID, содержит перечень шифронаборов, которые поддерживает клиент. (Это всё хорошо видно в выдаче тестового сервера.) Сокращённый пример: 0x1301, 0x1303, 0x1302, 0xC02B, 0xC02F… На уровне потока данных это всё просто последовательные значения байтов, по два байта на каждый идентификатор шифронабора (понятно, что данному блоку предшествуют байты с записью длины, что добавляет “узнаваемости”).

Так, для конкретной версии браузера перечень шифронаборов – узнаваем. В принципе, ничто не мешает клиенту менять состав и порядок пар байтов, обозначающих шифронаборы, но, например, Firefox передаёт фиксированный набор. Понятно, что строгая последовательность из 36 байтов – это уже достаточный идентифицирующий признак. (36 байтов получается так: 17 идентификаторов шифронаборов от Firefox, по два байта каждый, плюс два байта на запись длины.) Чуть более подробный пример, начальная часть ClientHello TLS 1.3:

 Type (тип сообщения, 0x01, один байт - подходит для сигнатуры);
 Len (длина сообщения, три байта - подходит для сигнатуры: должно соответствовать общей структуре);
 Version (версия, 0x0303, два байта - подходит для сигнатуры);
 Random ([...], 32 "случайных" байта - не подходит для сигнатуры);
 SessionID_Len (длина данных Session_ID, один байт, для TLS 1.3 - подходит для сигнатуры);
 SessionID (обычно, для TLS 1.3 от браузера тут будет 32 байта - не подходит для сигнатуры).
 CS_Len (длина данных списка шифронаборов, два байта - подходит для сигнатуры);
 CS (список двухбайтовых идентификаторов шифронаборов - подходит для сигнатуры).
 [...]

При этом, скажем, браузер Chromium/Chrome добавляет к списку шифронаборов так называемые значения GREASE (для тестирования реализаций TLS), которые меняются от сеанса к сеансу. Но значения GRASE имеют строго определённый формат, так что их несложно распознать автоматом. Если взять такой клиент, как cURL, то состав ClientHello будет другим, в частности, другим будет список шифронаборов. Более того, по составу ClientHello нередко можно определить даже используемую библиотеку, реализующую TLS.

Естественно, не только шифронаборы подходят для построения сигнатуры. В ClientHello современных браузеров присутствует разнообразный набор расширений – это дописываемые в сообщение поля со своей структурой: они содержат заголовок с записью длины, дополнительные блоки внутри. Для TLS 1.3 расширения имеют определяющее значение. Внутри расширений передаются различные необходимые параметры, в частности, открытая часть протокола Диффи-Хеллмана и открытый ключ постквантовой криптосистемы X25519Kyber768. По составу и количеству расширений можно построить дополнительную сигнатуру. Так, уже наличие X25519Kyber768 едва ли не однозначно выдаёт современный веб-браузер. А ведь современный браузер ещё и укажет расширение ECH (Encrypted ClientHello). Firefox использует зафиксированный порядок расширений ClientHello, а браузер Chromium/Chrome – порядок следования расширений изменяет между сессиями. Однако даже в случае, когда порядок расширений разный, всё равно можно использовать перечень имеющихся расширений для построения сигнатуры.

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

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

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

Проверка подписи для рассматриваемого способа использования проводится при помощи открытого ключа, опубликованного в TLS-сертификате. Тут возникает административный момент, связанный с политикой управления доверием, используемой приложением на проверяющей стороне. Это приложение может “верить в сертификат”, а может – “верить в сам ключ”.

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

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

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

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

Момент первый, – достаточно очевидный, – в том, что этот “суперпродвинутый” искусственный интеллект даже не способен прочитать условие задачи и, предположим, перевести его на формальный язык самостоятельно, хоть это и могло бы быть типичным вариантом запроса к ChatGPT. Так как для корректного перевода нужно хорошо понимать не только задачу, но и принципы построения формальных языков, выдача подобного ИИ-перевода для входа “системы ИИ” просто не подходит. Это понятно.

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

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

Исследователи, сравнивая в автоматизированном режиме (fuzzing) поведение различных микропроцессоров семейства RISC-V, обнаружили дефекты команд в линейке распространённых ЦПУ T-Head C910. Дефекты относятся к конкретной реализации и расширениям RISC-V, которые могут использовать разработчики совместимой аппаратуры.

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

(Новость OpenNet.)

Официальная новость ТЦИ про добавление определения X25519Kyber768 на audit.statdom.ru (САБИУ). Цитата:

На серверной стороне поддержка реализована, например, на узлах Google и веб-фронтендах Cloudflare, одного из крупнейших мировых провайдеров веб-доступа. То есть существенная часть веб-трафика в Интернете уже защищена с помощью данной криптосистемы.

Вообще, этот момент почему-то сейчас упускают из виду: может, оно и прошло незаметно, но сейчас, если вы используете Google или Youtube через более или менее современный браузер из распространённых, TLS-трафик уже защищён при помощи ключей, полученных с использованием Kyber768 – то есть, постквантовой криптосистемы. А если сюда добавить, что очень многие мало-мальски популярные сайты используют Cloudflare, – в том числе, в Рунете этот сервис очень распространён, – то окажется, что немалая часть обычного TLS-трафика в Вебе, – точно больше трети, – уже перешла, так сказать, на “постквантовые ключи”. А момент довольно интересный, но почему-то про него не особо-то пишут даже технические СМИ.

(Кстати, по наличию поддержки на стороне сервера можно, – примерно, – судить, у кого насколько “свой” TLS-бэкенд. Тоже занимательно.)

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

Понятно, конечно, что к результатам, полученным “сертифицированными смартфонами”, добавят метки, по которым такой классификатор ИИ-генераторов будет уверенно отличать “подлинные” сгенерированные видеопотоки и статичные фотоснимки от “поддельных” сгенерированных фотоснимков и видеопотоков (чистые технологии постструктурализма).

Кстати, вопрос о том, что, в случае работы электронных схем и видеопроцессоров, считать подлинником – довольно занимателен сам по себе.

Посмотрим на совсем небольшой фрагмент кода.

while(1){
	GP0 = 0;
	GP0 = 1;
}

Этот код предназначен для микроконтроллера PIC12F675 (один из очень популярных и очень простых микроконтроллеров) и, можно считать, написан на C (но здесь это не важно). Некоторые пояснения для тех, кто с микроконтроллерами дела не имел: микроконтроллеры предназначены для управления прочей электроникой и электротехникой, а GP0 здесь – это такой “синтаксический сахар”, а именно – способ задать логическое значение на выводе микроконтроллера при помощи специальной, зарезервированной переменной. PIC12F675 имеет несколько подходящих выводов, все они пронумерованы: GP0..GP5 (GP – это от General Purpose). Строчкам кода, приведённым выше, ещё предшествует несколько строк, настраивающих начальное состояние микроконтроллера и задающих режим работы, это здесь тоже не важно, поскольку речь пойдёт о другом.

Итак, GP0 = 0 – “записывает” в нулевой выход логический ноль, GP0 = 1 – “записывает” логическую единицу. Так что это не совсем “запись переменной”. Вариант while(1) – не менее типовой для мира микроконтроллеров способ задать бесконечный цикл. У микроконтроллера нет развесистой операционной системы. В алгоритмическом смысле, микроконтроллеры, обычно, либо спят, либо работают в бесконечном цикле while(1), иногда – то есть, очень редко, – отвлекаясь на обработку прерываний (в данном случае, считаем, что никаких прерываний и прочих неожиданностей не происходит).

Получается, что приведённый фрагмент последовательно выполняет запись ноля и единицы в логический вывод. Какой сигнал образуется на этом выводе? Пусть логические уровни задаются напряжением 0 вольт – для ноля и +5 вольт – для единицы (на практике, понятно, используется отсечение по порогу, но, опять же, это детали из области микроэлектроники). Нетрудно предположить, что некоторые предложения языка высокого уровня C аппаратурой выполняются пошагово, а значит, на выводе с номером ноль должен появиться ноль, а потом единица, а потом опять ноль, опять единица и так далее. Продолжительность импульса – ключевой момент, о нём как раз и пойдёт речь.

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

Однако, если скомпилировать код, прошить программу в микроконтроллер, запустить его и подключить осциллограф к нужному выводу, то картина получится несколько иная, меандр не очень-то сбалансирован. Вот результат на фото ниже.

(Здесь я использовал компилятор Microchip MPLAB XC8 версии 2.46, в бесплатном варианте.) Единицы получились в четыре раза длиннее нолей (здесь положительное направление, как обычно, вверх). Как так вышло? Вообще, “чисто структурное” понимание исходного кода подразумевает, что while(1) лишь задаёт бесконечный цикл – это доступно компилятору, а как там работают остальные детали, какой алгоритм задуман – компилятор учитывать не может. То есть, текст на ЯВУ задаёт лишь схему итераций. Это логично, но иногда нужно знать ассемблер и то, как работает аппаратура. В данном случае, происходит следующее.

Микроконтроллер работает со скоростью миллион программных тактов в секунду. Компилятор превращает цикл с двумя присваиваниями в некоторый набор кодов команд микроконтроллера. Реализация цикла должна использовать команду безусловного перехода, которая тоже потребляет такты. При этом начало цикла содержит дополнительную команду, задающую способ адресации регистров. В итоге, получается следующий набор машинных команд, которые, в результате прошивки, выполняет микроконтроллер (псевдокод, соответствующий ассемблеру; здесь loop – это метка, по которой происходит передача управления каждый раз в конце тела цикла):

loop:
 STATUS 5      // выбор режима адресации, один такт;
 SET_BIT_GP0 0 // установка бита вывода GP0 в ноль, один такт;
 SET_BIT_GP0 1 // установка бита вывода GP0 в единицу, один такт;
 GOTO loop     // переход к началу цикла, два такта;

В данном микроконтроллере GOTO (безусловный переход) занимает два программных такта, а остальные упомянутые команды – по одному. Это означает, что в цикле, между переключениями статуса вывода, будет четыре такта. Здесь перед последней командой (GOTO) вывод установлен в единицу (SET_BIT_GP0 1). Посчитаем, начиная с команды, устанавливающей единицу, такты: 1 (SET_BIT_GP0) + 2 (GOTO) + 1 (STATUS) == 4 такта. После чего вывод устанавливается в ноль на один такт. Интерпретация полностью соответствует картинке с осциллографа. Ниже, для сравнения, соответствующий фрагмент кода уже на ассемблере PIC. Точно в такой код преобразует исходную конструкцию с while(1) компилятор. Для задания состояния логического вывода микроконтроллер использует один бит в специальном регистре, поэтому тут выведены команды, устанавливающие (bsf) и сбрасывающие (bcf) биты.

mainloop: // while(...)
	bcf status, 5 // выбор режима адресации;
	bcf (5), 0    // GP0 = 0 (clear bit);
	bsf (5), 0    // GP0 = 1 (set bit);
	goto mainloop // while(1);

Получается, вывод компилятора тут не соответствовал ожиданиям при элементарном подходе. Но, конечно, догадаться о том, что реализация цикла тоже требует некоторых команд – не так трудно. Вообще же, текст программы ничего не говорит об организации цикла: while(1){…} только описывает его границы, это чисто структурный элемент, если воспринимать реализацию на высоком уровне – на языке высокого уровня.

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

Вернёмся к рисованию меандра программой для микроконтроллера. Хотелось бы получить “ровный” меандр. На языке C для PIC в нашем конкретном случае это можно сделать так.

while(1){
	GPIO = GPIO^0x01;
}

Здесь присваивание значений конкретным выводам заменено на XOR для всего регистра. GPIO – это псевдоним, обозначающий тот самый специальный регистр (массив битов), биты которого соответствуют конкретным логическим выводам. В нашем случае – переключается нулевой вывод (GP0), поэтому изменяется младший бит (бит с индексом нуль, этому соответствует значение маски – 0x01, единица). Логика, стоящая за данным решением, следующая: нужно исключить из тела цикла двойственность состояний. А именно – XOR переключает бит: если там был ноль, то будет единица, если была единица, то станет ноль; тут больше нет записи двух разных значений. Такой вариант кода гораздо лучше соответствует задаче, если бы задачей было получение “ровного, сбалансированного” меандра (заметьте, впрочем, что изначальная задача этой записки – другая: определить, что выводится микроконтроллером и, главное, почему).

Меандр “сбалансировался”, а результат, демонстрируемый осциллографом, поменялся, что и видно на фото экрана ниже.

Однако длительность каждого импульса теперь равна шести тактам. Почему? Потому что компилятор дописал новых команд, опасаясь за целостность общей логики кода: значения в регистрах микроконтроллера могут поменяться вне зависимости от работы АЛУ (арифметико-логического устройства). И это только нам известно, что подобные изменения не предусмотрены ни схемой включения, ни настройками микроконтроллера, а вот компилятор про это догадаться не может, поскольку компилятор не видит сам алгоритм.

Если PIC-ассемблер взять, что называется, в руки, то данный цикл можно оптимизировать. Во-первых, команду выбора схемы адресации можно вынести за пределы цикла, так как выбор зафиксирован. Это сэкономит один такт. Во-вторых, компилятор здесь записывает предложение “GPIO = GPIO^0x01” в три команды: загружает значение специального регистра GPIO в рабочий регистр (в PIC-микроконтроллерах он называется W), выполняет XOR и записывает значение в GPIO. Но нужный XOR можно сделать в одну команду, загрузив заранее, до начала цикла, маску (единицу) в рабочий регистр W и выполняя XOR непосредственно с GPIO. Это позволит сэкономить ещё два такта. А вот два такта, нужных на goto – так сэкономить уже не выйдет (можно, наверное, придумать особенно экзотические методы, но это на общий смысл не повлияет). Естественно, всё это возможно только потому, что задача сводится к преобразованию цикла записи состояний в значение одного логического вывода микроконтроллера, но в итоге – можно добиться трёх тактов на цикл. Соответствующий фрагмент ассемблерного кода приведён ниже.

        bcf     status, 5
        movlw   0x01
mainloop:
        xorwf   (5), 1
        goto    mainloop

Теперь импульсы стали короче в два раза, что и подтверждается очередной фотографией экрана осциллографа.

Конечно, реальная ситуация может быть сложнее, а компилятор может “догадаться” о какой-то лучшей оптимизации. Если рассматривать современные мощные микропроцессоры, то там, например, вообще сложно судить о реальном количестве тактов, затрачиваемых той или иной машинной командой, даже на уровне ассемблера. Ассемблер сейчас не всегда нужен, даже если нужно программировать микроконтроллеры, но знакомство с ассемблерами и принципами работы той аппаратуры, на которой программа будет исполняться, часто помогает осознать причины несоответствия ожиданий тексту программы на языке высокого уровня.

Очередное “ИИ решает математические задачи”, в этот раз – от Google и про олимпиадные задачи, но, хотя бы, есть уточнения про ограничения. В исходном сообщении сказано, что “AI achieves silver-medal standard solving International Mathematical Olympiad problems” (“ИИ достиг уровня серебряной медали, решая задачи Международной математической олимпиады”).

Если прочитать сообщение внимательно, то оказывается, что, на первом шаге, задачи были вручную переформулированы в виде предложений на формальном языке, который “подходит для системы”. Буквально: “First, the problems were manually translated into formal mathematical language for our systems to understand” – “Прежде всего, задачи были вручную переведены на формальный математический язык, чтобы наши системы их поняли”. То есть, данный ИИ, – который, как теперь напишут в СМИ (не Google), “демонстрирует уровень серебряного медалиста Международной математической олимпиады”, – даже не может прочитать задачи в том виде, как они представлены для людей (я, собственно, давно привожу этот момент в качестве примера).

Под “формальным математическим языком”, судя по всему, имеется в виду язык системы компьютерных доказательств Lean. То есть, речь, конечно, не про то, что задачу просто “записали строго”: исходные формулировки и так достаточно строгие. Заметьте, что корректный перевод исходного текста задачи на тот или иной формальный язык требует достаточно высокой квалификации и, обычно, примерного понимания сути самой задачи. Рассматриваемой системе ИИ этот шаг, очевидно, недоступен.

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

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

С “червём” CrowdStrike, конечно, странная история, но не менее странно и то, что уж в корпоративной-то Windows-среде есть все штатные способы настроить тестовую зону для раскатки обновлений. То есть, обновления должны сперва локально раздаваться только на некоторые машины, где отдельная служба может проверить, что оно не сломало всё, куда дотянулось, а только потом, когда некоторая уверенность появилась, обновления можно попробовать применять дальше. Наверное, с CrowdStrike ситуация другая. Наверное, можно так устроить программу-агента с центральным управлением, что она сломается только после того, как расползётся по достаточному количеству компьютеров.

Да, понятно, что описанный способ администрирования, с контролируемым изменением системного ПО, как и многие смежные технологии, это сейчас скорее из области теории, поскольку на практике, когда у вас есть внешний “непогрешимый ИИ”, управляющий “безопасностью ИТ-решений”, то этот ИИ может сам центрально раздать любой код на любые машины, где работают его “пробники”, поскольку windows-операторы свою часть уже сделали в самом начале: “прокликали Next->Next->Next до Finish”.

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

В статье Situational Awareness, которую я недавно упоминал, уровень “интеллекта” LLM GPT-4 (ChatGPT) неоднократно обозначен как соответствующий продвинутому старшему школьнику (smart high schooler). Появился свежий препринт (Vision Language Models are blind) на эту же тему, в котором, впрочем, выясняют, что самые продвинутые современные системы LLM – точнее, VLM, в том числе, GPT-4o, – не могут справиться с элементарными задачками, которые под силу и не особо продвинутому дошкольнику.

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

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

Не справляются представленные ИИ-системы и с другими элементарными задачами: определить выделенную букву в слове, посчитать количество окружностей, определить, пересекаются ли круги, и т.д., и т.п.

Понятно, что речь тут может идти только о стопроцентном результате, когда верно указаны все ответы. Для “продвинутого старшего школьника” подсчёт точек пересечения линий на подобной картинке – более чем элементарная задача. Угадывание же при помощи оптимизированного перебора, которое выдают за “думание” для данных систем, тут не производит никакого впечатления. Лучший результат, который приводят в работе, это угадывание в ~77% случаев, продемонстрированное VLM Sonnet-3.5; GPT-4o – лишь около 49%, при этом, по формулировке задачи, случайный выбор ответа, без учёта картинки, дал бы одну треть верно угаданных результатов.

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