Что такое ретполин и как он работает?

статьи упомянутый sgbj в комментариях, написанных полом Тернером Google, объясняет следующее гораздо более подробно, но я дам ему шанс:

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

основной подход можно увидеть в ветвь ядра Энди Клина решения этой проблемы:

он вводит новый __x86.indirect_thunk вызов, который загружает цель вызова, чей адрес памяти (который я буду называть ADDR) хранится в верхней части стека и выполняет прыжок с помощью RET инструкция. Затем сам thunk вызывается с помощью NOSPEC_JMP / CALL макрос, который использовался для замены многих (если не всех) косвенных вызовов и переходов. Макрос просто помещает цель вызова на стеке и устанавливает обратный адрес правильно, если это необходимо (обратите внимание на нелинейный поток управления):

.macro NOSPEC_CALL target
    jmp     1221f            /* jumps to the end of the macro */
1222:
    push    \target          /* pushes ADDR to the stack */
    jmp __x86.indirect_thunk /* executes the indirect jump */
1221:
    call    1222b            /* pushes the return address to the stack */
.endm

размещение call в конце концов необходимо так, что когда косвенный вызов закончен, поток управления продолжается за использованием NOSPEC_CALL макрос, поэтому его можно использовать вместо обычного call

сам стук выглядит следующим образом:

    call retpoline_call_target
2:
    lfence /* stop speculation */
    jmp 2b
retpoline_call_target:
    lea 8(%rsp), %rsp 
    ret

поток управления может немного запутаться здесь, так что позвольте мне уточните:

• call помещает указатель текущей инструкции (метка 2) в стек.
• lea добавляет 8 к указатель стека, фактически отбрасывая совсем недавно толкнул четверных, который является последним обратный адрес (на этикетке 2). После этого вершина стека снова указывает на реальный обратный адрес ADDR.
• ret скачков *ADDR и сбрасывает указатель стека в начале вызова стек.

в конце концов, все это поведение практически эквивалентно прыжку прямо в *ADDR. Одно преимущество, которое мы получаем, заключается в том, что предсказатель ветвей используется для операторов return (Return Stack Buffer, RSB) при выполнении call инструкция, предполагает, что соответствующий ret оператор перейдет к метке 2.

часть после метки 2 на самом деле никогда не выполняется, это просто бесконечный цикл, который бы теоретически заполнить конвейер инструкций с JMP инструкция. С помощью LFENCE,PAUSE или в более общем случае инструкция, вызывающая остановку конвейера инструкций, останавливает процессор от потери любой мощности и времени на это спекулятивное выполнение. Это потому, что в случае, если вызов retpoline_call_target вернется нормально, то LFENCE будет следующая инструкция, которая будет выполнена. Это также то, что предсказатель ветвей будет предсказывать на основе исходного обратного адреса (метки 2)

цитата из руководства Intel по архитектуре:

инструкции, следующие за LFENCE, могут быть извлечены из памяти до LFENCE, но они не будут выполняться до завершения LFENCE.

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

теперь вернемся к вашему изначальному вопросу: Информация о памяти ядра раскрытие возможно благодаря сочетанию двух идей:

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

• косвенный предсказатель ветвей процессоров Intel использует только самые нижние 12 бит исходной инструкции, поэтому легко отравить все 2^12 возможных историй предсказания с помощью адресов памяти, управляемых пользователем. Они могут тогда, когда косвенный скачок предсказан в ядре, быть спекулятивно выполняется с правами ядра. Используя боковой канал синхронизации кэша, вы можете таким образом утечка произвольной памяти ядра.

обновление: на список рассылки ядра, есть продолжающееся обсуждение, которое заставляет меня полагать, что ретполины не полностью смягчают Проблемы прогнозирования ветвей, так как когда буфер стека возврата (RSB) работает пустым, более поздние архитектуры Intel (Skylake+) возвращаются к уязвимому целевому буферу ветви (BTB):

Retpoline в качестве стратегии по смягчению последствий проскакивают косвенные филиалы для возвращения, чтобы избежать использования прогнозов, которые поступают из BTB, поскольку они могут быть отравлены злоумышленником. Проблема с Skylake+ заключается в том, что RSB underflow возвращается к использованию BTB предсказание, которое позволяет злоумышленнику взять под контроль спекуляции.