C++-Entwickler-Leitfaden für spekulative Ausführung dienstseitige KanäleC++ Developer Guidance for Speculative Execution Side Channels

Dieser Artikel enthält Anleitungen für Entwickler zur Unterstützung beim Identifizieren und Beheben von Sicherheitsrisiken durch spekulative Ausführung Seite Kanal Hardware in der C++-Software.This article contains guidance for developers to assist with identifying and mitigating speculative execution side channel hardware vulnerabilities in C++ software. Diese Sicherheitsrisiken können sensible Informationen offengelegt werden über Vertrauensgrenzen hinweg und können die Software, die auf Prozessoren ausgeführt wird, die spekulative Ausführung außerhalb der Reihenfolge von Anweisungen unterstützen beeinträchtigen.These vulnerabilities can disclose sensitive information across trust boundaries and can affect software that runs on processors that support speculative, out-of-order execution of instructions. Diese Klasse von Sicherheitsrisiken wurde zuerst im Januar 2018 beschrieben und zusätzliche Hintergrundinformationen und Anleitungen finden Sie im von Microsoft-sicherheitsempfehlung.This class of vulnerabilities was first described in January, 2018 and additional background and guidance can be found in Microsoft's security advisory.

Die Anleitung in diesem Artikel bezieht sich auf die Klassen von Sicherheitsrisiken durch dargestellt:The guidance provided by this article is related to the classes of vulnerabilities represented by:

  1. CVE-2017-5753, auch bekannt als Spectre-Variante 1.CVE-2017-5753, also known as Spectre variant 1. Dieses Sicherheitsrisiko Hardwareklasse bezieht sich auf dienstseitige Kanäle, die aufgrund der spekulativen Ausführung auftreten können, die als Ergebnis eine bedingte Verzweigung Misprediction auftritt, haben.This hardware vulnerability class is related to side channels that can arise due to speculative execution that occurs as a result of a conditional branch misprediction. Microsoft C++ -Compiler in Visual Studio 2017 (ab Version 15.5.5) bietet Unterstützung für die /Qspectre eine Lösung während der Kompilierung für eine begrenzte Anzahl von potenziell anfällige Codierungsmuster bietet-Schalter im Zusammenhang mit der CVE-2017-5753.The Microsoft C++ compiler in Visual Studio 2017 (starting with version 15.5.5) includes support for the /Qspectre switch which provides a compile-time mitigation for a limited set of potentially vulnerable coding patterns related to CVE-2017-5753. Die /Qspectre Switch steht auch in Visual Studio 2015 Update 3 über KB 4338871.The /Qspectre switch is also available in Visual Studio 2015 Update 3 through KB 4338871. Die Dokumentation für die "/ qspectre" Flag enthält weitere Informationen zu dessen Auswirkungen und Nutzung.The documentation for the /Qspectre flag provides more information on its effects and usage.

  2. CVE-2018-3639, auch bekannt als spekulative Store umgehen (SSB).CVE-2018-3639, also known as Speculative Store Bypass (SSB). Dieses Sicherheitsrisiko Hardwareklasse bezieht sich auf dienstseitige Kanäle, die aufgrund der spekulativen Ausführung eines Auslastungstests vor einem abhängigen Speicher als Ergebnis eine Arbeitsspeicher-Access-Misprediction auftreten können.This hardware vulnerability class is related to side channels that can arise due to speculative execution of a load ahead of a dependent store as a result of a memory access misprediction.

Einführung zugegriffen werden kann spekulative Ausführung Seite ausführungsseitigen channelsicherheitsanfälligkeiten finden Sie in der Präsentation, die mit dem Titel die Groß-/Kleinschreibung der Spectre und Meltdown von einem der Research-Teams, die diese Probleme ermittelt.An accessible introduction to speculative execution side channel vulnerabilities can be found in the presentation titled The Case of Spectre and Meltdown by one of the research teams that discovered these issues.

Was sind Spekulatives Ausführung Seite Kanal Hardware Sicherheitsrisiken?What are Speculative Execution Side Channel hardware vulnerabilities?

Bei modernen CPUs höheres Maß an Leistung Geben Sie dazu mit der spekulativen und Out-of-Order-Ausführung von Anweisungen.Modern CPUs provide higher degrees of performance by making use of speculative and out-of-order execution of instructions. Angenommen, dies erfolgt häufig Vorhersage des Ziels der Branches (bedingte und indirekte) dadurch die CPU als spekulativer Ausführung von Aufgaben im Ziel vorhergesagten Branch zu beginnen und so eine Verzögerungszeit, bis die tatsächlichen Verzweigungsziel ist aufgelöst.For example, this is often accomplished by predicting the target of branches (conditional and indirect) which enables the CPU to begin speculatively executing instructions at the predicted branch target, thus avoiding a stall until the actual branch target is resolved. Wenn die CPU, dass eine Misprediction aufgetreten später ermittelt werden soll, werden alle Status des Computers, der spekulativer berechnet wurde verworfen.In the event that the CPU later discovers that a misprediction occurred, all of the machine state that was computed speculatively is discarded. Dadurch wird sichergestellt, dass keine architektonisch sichtbaren Auswirkungen der mispredicted Spekulatives vorhanden sind.This ensures that there are no architecturally visible effects of the mispredicted speculation.

Während der spekulativer Ausführung den architektonisch sichtbaren Zustand nicht beeinträchtigt, können sie residuale ablaufverfolgungen in nicht-Architektur Zustand befindet, z. B. die verschiedenen Caches lassen, die von der CPU verwendet werden.While speculative execution does not affect the architecturally visible state, it can leave residual traces in non-architectural state, such as the various caches that are used by the CPU. Es handelt sich um diese residual ablaufverfolgungen der spekulativen Ausführung, der zu Seite ausführungsseitigen channelsicherheitsanfälligkeiten führen können.It is these residual traces of speculative execution that can give rise to side channel vulnerabilities. Um dies zu verstehen, betrachten Sie das folgende Codefragment bietet ein Beispiel für CVE-2017-5753 (Begrenzungen überprüfen Umgehung) aus:To better understand this, consider the following code fragment which provides an example of CVE-2017-5753 (Bounds Check Bypass):

// A pointer to a shared memory region of size 1MB (256 * 4096)
unsigned char *shared_buffer;

unsigned char ReadByte(unsigned char *buffer, unsigned int buffer_size, unsigned int untrusted_index) {
    if (untrusted_index < buffer_size) {
        unsigned char value = buffer[untrusted_index];
        return shared_buffer[value * 4096];
    }
}

In diesem Beispiel ReadByte ist ein Puffer, eine Puffergröße sowie einen Index in diesen Puffer angegeben.In this example, ReadByte is supplied a buffer, a buffer size, and an index into that buffer. Der Indexparameter, laut untrusted_index, angegeben wird, mit einem kleiner privilegierten Kontext, z. B. ein Nichtadministrator-Prozess.The index parameter, as specified by untrusted_index, is supplied by a less privileged context, such as a non-administrative process. Wenn untrusted_index ist kleiner als buffer_size, und klicken Sie dann das Zeichen an diesem Index aus der gelesen wird buffer und zum Index in ein freigegebener Speicherbereich verweist shared_buffer.If untrusted_index is less than buffer_size, then the character at that index is read from buffer and used to index into a shared region of memory referred to by shared_buffer.

Aus Sicht der Architektur, diese Codesequenz ist absolut sicher, da sichergestellt ist, die untrusted_index immer kleiner als buffer_size.From an architectural perspective, this code sequence is perfectly safe as it is guaranteed that untrusted_index will always be less than buffer_size. Bei der spekulativen Ausführung, es ist jedoch möglich, dass die CPU wird die bedingten Verzweigung falschvorh, und führen Sie den Text zurück, wenn die Anweisung, auch wenn untrusted_index ist größer als oder gleich buffer_size.However, in the presence of speculative execution, it is possible that the CPU will mispredict the conditional branch and execute the body of the if statement even when untrusted_index is greater than or equal to buffer_size. Daher kann die CPU einen Byte außerhalb der Grenzen des spekulativer lesen buffer (die möglicherweise einen geheimen Schlüssel) und klicken Sie dann, Byte-Wert verwenden können, um die Adresse einer nachfolgenden Last durch berechnen shared_buffer.As a consequence of this, the CPU may speculatively read a byte from beyond the bounds of buffer (which could be a secret) and could then use that byte value to compute the address of a subsequent load through shared_buffer.

Während die CPU dieses Misprediction schließlich erkannt werden, möglicherweise residual Nebeneffekte bleiben in der CPU-Cache, der Informationen zu den Bytewert anzuzeigen, die außerhalb des gültigen Bereichs von gelesen wurde buffer.While the CPU will eventually detect this misprediction, residual side effects may be left in the CPU cache that reveal information about the byte value that was read out of bounds from buffer. Diese Nebenwirkungen kann erkannt werden, indem ein kleiner privilegierten Kontext, die auf dem System ausgeführt wird, wie schnell Überprüfung jeder Cache Zeile, in shared_buffer zugegriffen wird.These side effects can be detected by a less privileged context running on the system by probing how quickly each cache line in shared_buffer is accessed. Sind die Schritte, die ausgeführt werden können, um dies zu erreichen:The steps that can be taken to accomplish this are:

  1. Rufen Sie ReadByte mehrmals mit untrusted_index wird weniger als buffer_size .Invoke ReadByte multiple times with untrusted_index being less than buffer_size. Der angreifende Kontext kann dazu führen, dass das Opfer-Kontext aufrufen ReadByte (z. B. über RPC), der das Vorhersageergebnis Branch ist z. B. trainiert, um Sie als nicht durchgeführt werden untrusted_index ist kleiner als buffer_size.The attacking context can cause the victim context to invoke ReadByte (e.g. via RPC) such that the branch predictor is trained to be not-taken as untrusted_index is less than buffer_size.

  2. Alle Cachezeilen in leeren shared_buffer .Flush all cache lines in shared_buffer. Der angreifende Kontext muss alle Cachezeilen, die in der Region freigegebenen Speicher verweist leeren shared_buffer.The attacking context must flush all of the cache lines in the shared region of memory referred to by shared_buffer. Da Arbeitsspeicherbereichs freigegeben wird, dies ist einfach und kann erreicht werden, mithilfe von systeminternen Funktionen wie z. B. _mm_clflush.Since the memory region is shared, this is straightforward and can be accomplished using intrinsics such as _mm_clflush.

  3. Rufen Sie ReadByte mit untrusted_index größer als buffer_size .Invoke ReadByte with untrusted_index being greater than buffer_size. Der angreifende Kontext bewirkt, dass das Opfer-Kontext aufrufen ReadByte so, dass es falsch vorhergesagt wird, dass die Verzweigung nicht ausgeführt werden.The attacking context causes the victim context to invoke ReadByte such that it incorrectly predicts that the branch will not be taken. Dieser bewirkt, dass der Prozessor spekulativer führen Sie den Text der If-block mit untrusted_index größer als buffer_size, werden daher zu einer außerhalb des gültigen Bereichs lesen führende von buffer.This causes the processor to speculatively execute the body of the if block with untrusted_index being greater than buffer_size, thus leading to an out-of-bounds read of buffer. Folglich shared_buffer werden indiziert, verwenden einen potenziell geheimen-Wert, der außerhalb des gültigen Bereichs, wodurch von der CPU geladen werden die jeweiligen Cachezeile gelesen wurde.Consequently, shared_buffer is indexed using a potentially secret value that was read out-of-bounds, thus causing the respective cache line to be loaded by the CPU.

  4. Lesen jede Cachezeile in shared_buffer angezeigt, die am schnellsten zugegriffen wird.Read each cache line in shared_buffer to see which is accessed most quickly. Der angreifende Kontext erhalten jede Cachezeile in shared_buffer und erkennen die Cachezeile, die erheblich schneller als die anderen lädt.The attacking context can read each cache line in shared_buffer and detect the cache line that loads significantly faster than the others. Dies ist die Cachezeile, die wahrscheinlich zu den Schritt 3 eingegeben wurden.This is the cache line that is likely to have been brought in by step 3. Da eine 1:1-Beziehung zwischen Byte-Wert und die Cache-Zeile in diesem Beispiel ist, wird dadurch den Angreifer, den tatsächlichen Wert des Bytes abzuleiten, die außerhalb des gültigen Bereichs gelesen wurde.Since there is a 1:1 relationship between byte value and cache line in this example, this allows the attacker to infer the actual value of the byte that was read out-of-bounds.

Die oben genannten Schritte geben Sie ein Beispiel der Verwendung von Technik leeren + neu laden in Verbindung mit eine Instanz von CVE-2017-5753 ausnutzen.The above steps provide an example of using a technique known as FLUSH+RELOAD in conjunction with exploiting an instance of CVE-2017-5753.

Welche Szenarien für die Software können betroffen sein?What software scenarios can be impacted?

Entwicklung von sicherer Software, die mit einem Prozess wie die Security Development Lifecycle (SDL) in der Regel muss die Vertrauensgrenzen zu identifizieren, die in der Anwendung vorhanden sind.Developing secure software using a process like the Security Development Lifecycle (SDL) typically requires developers to identify the trust boundaries that exist in their application. An Orten, in denen eine Anwendung mit Daten von einem weniger vertrauenswürdigen Kontext, wie z. B. ein anderer Prozess auf dem System oder einen Benutzer ohne Administratorrechte-Modus-Prozess bei einem Kernelmodus-Gerätetreiber interagieren kann, ist eine Vertrauensgrenze vorhanden.A trust boundary exists in places where an application may interact with data provided by a less-trusted context, such as another process on the system or a non-administrative user mode process in the case of a kernel-mode device driver. Die neue Klasse von Sicherheitsrisiken, die im Zusammenhang mit spekulativer Ausführung dienstseitige Kanäle ist relevant für viele die Vertrauensgrenzen in Software Security Modelle, die Isolieren von Code und Daten auf einem Gerät.The new class of vulnerabilities involving speculative execution side channels is relevant to many of the trust boundaries in existing software security models that isolate code and data on a device.

Die folgende Tabelle enthält eine Zusammenfassung der Software Sicherheitsmodelle, in denen Entwickler kümmern diese Sicherheitsrisiken, die auftreten müssen unter Umständen:The following table provides a summary of the software security models where developers may need to be concerned about these vulnerabilities occurring:

VertrauensgrenzeTrust boundary BeschreibungDescription
Virtual Machine-GrenzeVirtual machine boundary Anwendungen, die Isolierung von Workloads in separate virtuelle Computer, die nicht vertrauenswürdige Daten von einem anderen virtuellen Computer erhalten möglicherweise gefährdet.Applications that isolate workloads in separate virtual machines that receive untrusted data from another virtual machine may be at risk.
KernelgrenzeKernel boundary Ein im Kernelmodus-Gerätetreiber, der nicht vertrauenswürdige Daten von einem Benutzer ohne Administratorrechte-Modus-Prozess empfängt möglicherweise gefährdet.A kernel-mode device driver that receives untrusted data from a non-administrative user mode process may be at risk.
ProzessgrenzeProcess boundary Eine Anwendung, die nicht vertrauenswürdige Daten von einem anderen Prozess ausgeführt wird, auf dem lokalen System, empfängt, wie z. B. über eine (Remoteprozeduraufruf), freigegebenen Speicher oder andere prozessübergreifende Kommunikation (IPC) Mechanismen gefährdet sein können.An application that receives untrusted data from another process running on the local system, such as through a Remote Procedure Call (RPC), shared memory, or other Inter-Process Communication (IPC) mechanisms may be at risk.
Enclave-GrenzeEnclave boundary Eine Anwendung, die in eine sichere Enclave (z. B. Intel SGX) ausgeführt wird, die nicht vertrauenswürdige Daten von außerhalb der Enclave empfängt möglicherweise gefährdet.An application that executes within a secure enclave (such as Intel SGX) that receives untrusted data from outside of the enclave may be at risk.
SprachgrenzeLanguage boundary Eine Anwendung, die interpretiert oder Just-in-Time (JIT) kompiliert und nicht vertrauenswürdigen Code in der führt eine höherrangige Sprache möglicherweise gefährdet.An application that interprets or Just-In-Time (JIT) compiles and executes untrusted code written in a higher-level language may be at risk.

Anwendungen, die Angriffsfläche auf eine der oben genannten vertrauen, dass Code auf der Angriffsoberfläche zur Identifizierung und Minimierung von Instanzen der spekulativen Ausführung Seite ausführungsseitigen channelsicherheitsanfälligkeiten Grenzen geprüft werden soll.Applications that have attack surface exposed to any of the above trust boundaries should review code on the attack surface to identify and mitigate possible instances of speculative execution side channel vulnerabilities. Anzumerken ist, dass die Vertrauensgrenzen verfügbar gemacht werden, um remote Angriffsflächen, z. B. remote Netzwerkprotokollen, nicht gezeigt wurde, um spekulative Ausführung Seite ausführungsseitigen channelsicherheitsanfälligkeiten gefährdet werden.It should be noted that trust boundaries exposed to remote attack surfaces, such as remote network protocols, have not been demonstrated to be at risk to speculative execution side channel vulnerabilities.

Potenziell anfällige CodierungsmusterPotentially vulnerable coding patterns

Spekulative Ausführung Seite ausführungsseitigen channelsicherheitsanfälligkeiten können daher mehrere Codierungsmuster auftreten.Speculative execution side channel vulnerabilities can arise as a consequence of multiple coding patterns. In diesem Abschnitt wird beschrieben, potenziell anfällige Codierungsmuster und enthält Beispiele für die einzelnen allerdings, dass Variationen auf diese Themen vorhanden sind, können erkannt werden sollen.This section describes potentially vulnerable coding patterns and provides examples for each, but it should be recognized that variations on these themes may exist. Entwickler werden daher empfohlen, diese Muster als Beispiele und nicht als eine vollständige Liste aller potenziell anfällige Codierungsmuster werden.As such, developers are advised to take these patterns as examples and not as an exhaustive list of all potentially vulnerable coding patterns. Die gleichen Klassen Arbeitsspeicher Sicherheit Sicherheitsrisiken, die in der Software heute existieren kann auch zusammen mit spekulativer vorhanden sind, und Out-of-Order-Pfaden der Ausführung, aber nicht beschränkt auf Pufferüberläufe, einschließlich Arrays außerhalb des gültigen Bereichs zugreift, nicht initialisierter Speicher verwenden, geben Verwirrung und So weiter.The same classes of memory safety vulnerabilities that can exist in software today may also exist along speculative and out-of-order paths of execution, including but not limited to buffer overruns, out-of-bounds array accesses, uninitialized memory use, type confusion, and so on. Die gleichen Grundtypen, die Angreifer verwenden können, um Arbeitsspeicher Sicherheit Sicherheitslücken Architektur Pfaden ausnutzen können auch auf spekulative Pfade anwenden.The same primitives that attackers can use to exploit memory safety vulnerabilities along architectural paths may also apply to speculative paths.

Im Allgemeinen kann spekulative Ausführung Seite Kanäle im Zusammenhang mit der bedingten Verzweigung Misprediction auftreten, wenn es sich bei ein bedingter Ausdruck für Daten ausgeführt wird, die gesteuert oder durch einen Kontext an weniger vertrauenswürdigen beeinflusst werden können.In general, speculative execution side channels related to conditional branch misprediction can arise when a conditional expression operates on data that can be controlled or influenced by a less-trusted context. Dies kann z. B. einschließen bedingter Ausdrücke in if, for, while, switch, oder die ternäre Anweisungen.For example, this can include conditional expressions used in if, for, while, switch, or ternary statements. Für jede der folgenden Anweisungen generiert der Compiler kann einen bedingten Zweig, den die CPU klicken Sie dann das Branch-Ziel für die Laufzeit Vorhersagen kann.For each of these statements, the compiler may generate a conditional branch that the CPU may then predict the branch target for at runtime.

Für jedes Beispiel wird ein Kommentar mit dem Begriff "SPEKULATIONSBARRIERE" eingefügt, in denen ein Entwickler eine Barriere als Risikominderung führen konnte.For each example, a comment with the phrase "SPECULATION BARRIER" is inserted where a developer could introduce a barrier as a mitigation. Dies wird ausführlicher im Abschnitt auf Schutzmaßnahmen erläutert.This is discussed in more detail in the section on mitigations.

Außerhalb des gültigen Bereichs Spekulatives LadenSpeculative out-of-bounds load

Diese Kategorie von Codemuster umfasst eine bedingte Verzweigung Misprediction, die außerhalb des gültigen Bereichs für eine zu einer spekulativen führt Speicherzugriff.This category of coding patterns involves a conditional branch misprediction that leads to a speculative out-of-bounds memory access.

Array außerhalb des gültigen Bereichs zu laden, fügen einem AuslastungstestArray out-of-bounds load feeding a load

Dieses Codierungsmuster ist der ursprünglich beschrieben anfällig Codierungsmuster für CVE-2017-5753 (Begrenzungen überprüfen Umgehung).This coding pattern is the originally described vulnerable coding pattern for CVE-2017-5753 (Bounds Check Bypass). Die Hintergrund-Abschnitt dieses Artikels wird dieses Muster im Detail erläutert.The background section of this article explains this pattern in detail.

// A pointer to a shared memory region of size 1MB (256 * 4096)
unsigned char *shared_buffer;

unsigned char ReadByte(unsigned char *buffer, unsigned int buffer_size, unsigned int untrusted_index) {
    if (untrusted_index < buffer_size) {
        // SPECULATION BARRIER
        unsigned char value = buffer[untrusted_index];
        return shared_buffer[value * 4096];
    }
}

Ein Array außerhalb des gültigen Bereichs Load in Verbindung mit einer Schleife auftreten kann, die die Beendigung überschreitet aufgrund einer Misprediction auf ähnliche Weise-Bedingung.Similarly, an array out-of-bounds load may occur in conjunction with a loop that exceeds its terminating condition due to a misprediction. In diesem Beispiel die bedingten Verzweigung zugeordnet der x < buffer_size Ausdruck falschvorh und führen Sie den Text der spekulativer kann die for Schleife beim x ist größer als oder gleich buffer_size, daher in einer spekulativen resultierende Laden Sie außerhalb des gültigen Bereichs.In this example, the conditional branch associated with the x < buffer_size expression may mispredict and speculatively execute the body of the for loop when x is greater than or equal to buffer_size, thus resulting in a speculative out-of-bounds load.

// A pointer to a shared memory region of size 1MB (256 * 4096)
unsigned char *shared_buffer;

unsigned char ReadBytes(unsigned char *buffer, unsigned int buffer_size) {
    for (unsigned int x = 0; x < buffer_size; x++) {
        // SPECULATION BARRIER
        unsigned char value = buffer[x];
        return shared_buffer[value * 4096];
    }
}

Array außerhalb des gültigen Bereichs zu laden, fügen eine indirekte branchArray out-of-bounds load feeding an indirect branch

Dieses Codierungsmuster umfasst den Fall, in denen eine bedingte Verzweigung Misprediction kann führen zu, einer außerhalb des gültigen Bereichs der Zugriff auf ein Array von Funktionszeigern, die dann führt zu einer indirekten Verzweigung an das Ziel zu, die beheben, außerhalb des gültigen Bereichs gelesen wurde.This coding pattern involves the case where a conditional branch misprediction can lead to an out-of-bounds access to an array of function pointers which then leads to an indirect branch to the target address that was read out-of-bounds. Der folgende Codeausschnitt enthält ein Beispiel, die dies veranschaulicht.The following snippet provides an example that demonstrates this.

In diesem Beispiel wird ein nicht vertrauenswürdiger Nachrichten-ID bereitgestellt, um DispatchMessage über die untrusted_message_id Parameter.In this example, an untrusted message identifier is provided to DispatchMessage through the untrusted_message_id parameter. Wenn untrusted_message_id ist kleiner als MAX_MESSAGE_ID, wird es in ein Array von Funktionszeigern, indizieren und branch verwendet das entsprechende Branch-Ziel.If untrusted_message_id is less than MAX_MESSAGE_ID, then it is used to index into an array of function pointers and branch to the corresponding branch target. Dieser Code architektonisch sicher ist, aber wenn die CPU die bedingten Verzweigung falsch vorhergesagte zugeordnet werden, kann dies dazu führen DispatchTable von indizierten untrusted_message_id Wenn der Wert ist, größer als oder gleich MAX_MESSAGE_ID, werden daher führende zu einer außerhalb des gültigen Bereichs zuzugreifen.This code is safe architecturally, but if the CPU mispredicts the conditional branch, it could result in DispatchTable being indexed by untrusted_message_id when its value is greater than or equal to MAX_MESSAGE_ID, thus leading to an out-of-bounds access. Dies kann spekulative Ausführung aus der einer Zieladresse Branch führen, die über die Grenzen des Arrays abgeleitet ist, was zur Offenlegung von Informationen je nach Code führen konnte, die spekulativer ausgeführt wird.This could result in speculative execution from a branch target address that is derived beyond the bounds of the array which could lead to information disclosure depending on the code that is executed speculatively.

#define MAX_MESSAGE_ID 16

typedef void (*MESSAGE_ROUTINE)(unsigned char *buffer, unsigned int buffer_size);

const MESSAGE_ROUTINE DispatchTable[MAX_MESSAGE_ID];

void DispatchMessage(unsigned int untrusted_message_id, unsigned char *buffer, unsigned int buffer_size) {
    if (untrusted_message_id < MAX_MESSAGE_ID) {
        // SPECULATION BARRIER
        DispatchTable[untrusted_message_id](buffer, buffer_size);
    }
}

Wie im Fall eines Arrays außerhalb des gültigen Bereichs laden, fügen einen anderen laden, kann diese Bedingung auch in Verbindung mit einer Schleife auftreten, die der abschließende Zustand aufgrund einer Misprediction überschreitet.As with the case of an array out-of-bounds load feeding another load, this condition may also arise in conjunction with a loop that exceeds its terminating condition due to a misprediction.

Außerhalb des gültigen Bereichs Array speichern, fügen eine indirekte branchArray out-of-bounds store feeding an indirect branch

Während das vorherige Beispiel wie eine spekulative außerhalb des gültigen Bereichs beeinflussen die Auslastung kann eine indirekte Verzweigungsziel zeigte, es ist auch möglich, dass ein außerhalb des gültigen Bereichs speichern, um eine indirekte Branch-Ziel, z. B. einen Funktionszeiger oder eine Absenderadresse zu ändern.While the previous example showed how a speculative out-of-bounds load can influence an indirect branch target, it is also possible for an out-of-bounds store to modify an indirect branch target, such as a function pointer or a return address. Dies kann potenziell zur spekulative Ausführung von einem Angreifer Adresse führen.This can potentially lead to speculative execution from an attacker-specified address.

In diesem Beispiel wird ein nicht vertrauenswürdiger Index durch Übergeben der untrusted_index Parameter.In this example, an untrusted index is passed through the untrusted_index parameter. Wenn untrusted_index ist kleiner als die Anzahl der Elemente von der pointers Array (256 Elemente), und klicken Sie dann auf den Wert des bereitgestellten Zeigers, in ptr bezieht sich auf die pointers Array.If untrusted_index is less than the element count of the pointers array (256 elements), then the provided pointer value in ptr is written to the pointers array. Dieser Code architektonisch sicher ist, aber wenn die CPU die bedingten Verzweigung falsch vorhergesagte zugeordnet werden, kann dies dazu führen ptr spekulativer geschrieben wird, über die Grenzen des dem Stapel zugeordneten pointers Array.This code is safe architecturally, but if the CPU mispredicts the conditional branch, it could result in ptr being speculatively written beyond the bounds of the stack-allocated pointers array. Dies kann zu einer Beschädigung der spekulativen der Absenderadresse für führen WriteSlot.This could lead to speculative corruption of the return address for WriteSlot. Wenn ein Angreifer, den Wert der steuern kann ptr, sie möglicherweise dazu führen, dass bei der spekulativen Ausführung über einen beliebigen behandeln, wenn WriteSlot entlang des Pfads spekulative zurückgibt.If an attacker can control the value of ptr, they may be able to cause speculative execution from an arbitrary address when WriteSlot returns along the speculative path.

unsigned char WriteSlot(unsigned int untrusted_index, void *ptr) {
    void *pointers[256];
    if (untrusted_index < 256) {
        // SPECULATION BARRIER
        pointers[untrusted_index] = ptr;
    }
}

Auf ähnliche Weise, wenn eine lokale Variable Zeiger Funktion mit dem Namen func möglich, ändern Sie die Adresse spekulativer möglicherweise auf dem Stapel zugeordnet wurden, func bedeutet, dass die bedingte Verzweigung Misprediction tritt auf.Similarly, if a function pointer local variable named func were allocated on the stack, then it may be possible to speculatively modify the address that func refers to when the conditional branch misprediction occurs. Dies könnte, wenn der Funktionszeiger, durch aufgerufen wird spekulative Ausführung von einer beliebigen Adresse führen.This could result in speculative execution from an arbitrary address when the function pointer is called through.

unsigned char WriteSlot(unsigned int untrusted_index, void *ptr) {
    void *pointers[256];
    void (*func)() = &callback;
    if (untrusted_index < 256) {
        // SPECULATION BARRIER
        pointers[untrusted_index] = ptr;
    }
    func();
}

Anzumerken ist, dass in beiden Beispielen spekulative Änderung der Stapel zugeordneten indirekte branchzeiger umfassen.It should be noted that both of these examples involve speculative modification of stack-allocated indirect branch pointers. Es ist möglich, dass die spekulative Änderung auch für globale Variablen, den Heap reservierte Speicher und sogar schreibgeschützten Speicher für einige CPUs auftreten kann.It is possible that speculative modification could also occur for global variables, heap-allocated memory, and even read-only memory on some CPUs. Für den Stapel zugeordneten Arbeitsspeicher Microsoft C++ nimmt Compiler bereits Schritte aus, um erschweren spekulativer indirekte Branch Stapel zugeordneten Ziele, z. B. durch die neuanordnung von lokalen Variablen, sodass Puffer ein nebeneinander platziert werden geändert Cookie als Teil der /GS Compiler Sicherheitsfunktion.For stack-allocated memory, the Microsoft C++ compiler already takes steps to make it more difficult to speculatively modify stack-allocated indirect branch targets, such as by reordering local variables such that buffers are placed adjacent to a security cookie as part of the /GS compiler security feature.

Spekulative Typ VerwirrungSpeculative type confusion

Diese Kategorie behandelt Codemuster, die zu einer spekulativen Typ zu Verwirrung führen können.This category deals with coding patterns that can give rise to a speculative type confusion. Dies tritt auf, wenn Speicher mit einem falschen Typ auf einem nicht-Architektur Pfad während der spekulativen Ausführung zugegriffen wird.This occurs when memory is accessed using an incorrect type along a non-architectural path during speculative execution. Sowohl der bedingte Verzweigung Misprediction als auch der spekulativen Store umgehen können potenziell ein spekulative Typ Verwirrung stiften.Both conditional branch misprediction and speculative store bypass can potentially lead to a speculative type confusion.

Zur Umgehung der spekulativen Store kann dies in Szenarien auftreten, in denen ein Compiler eine Stapelspeicherort für Variablen mehrerer Typen verwendet.For speculative store bypass, this could occur in scenarios where a compiler reuses a stack location for variables of multiple types. Grund hierfür ist der architektonische Speicher für eine Variable vom Typ A möglicherweise umgangen werden, sodass die Last des Typs A spekulativer ausgeführt werden, bevor der Variablen zugewiesen wird.This is because the architectural store of a variable of type A may be bypassed, thus allowing the load of type A to speculatively execute before the variable is assigned. Wenn die zuvor gespeicherte Variable eines anderen Typs ist, können Sie dies die Bedingungen für eine Verwechslung spekulative Typ erstellen.If the previously stored variable is of a different type, then this can create the conditions for a speculative type confusion.

Für bedingte Verzweigung Misprediction, die im folgenden Codeausschnitt verwendet werden, um zu beschreiben verschiedene Bedingungen, die spekulative Typ Verwirrung bereitstellen kann steigt.For conditional branch misprediction, the following code snippet will be used to describe different conditions that speculative type confusion can give rise to.

enum TypeName {
    Type1,
    Type2
};

class CBaseType {
public:
    CBaseType(TypeName type) : type(type) {}
    TypeName type;
};

class CType1 : public CBaseType {
public:
    CType1() : CBaseType(Type1) {}
    char field1[256];
    unsigned char field2;
};

class CType2 : public CBaseType {
public:
    CType2() : CBaseType(Type2) {}
    void (*dispatch_routine)();
    unsigned char field2;
};

// A pointer to a shared memory region of size 1MB (256 * 4096)
unsigned char *shared_buffer;

unsigned char ProcessType(CBaseType *obj)
{
    if (obj->type == Type1) {
        // SPECULATION BARRIER
        CType1 *obj1 = static_cast<CType1 *>(obj);

        unsigned char value = obj1->field2;

        return shared_buffer[value * 4096];
    }
    else if (obj->type == Type2) {
        // SPECULATION BARRIER
        CType2 *obj2 = static_cast<CType2 *>(obj);

        obj2->dispatch_routine();

        return obj2->field2;
    }
}

Spekulative Typ zu Verwirrung führt zu einer außerhalb des gültigen Bereichs geladen werden.Speculative type confusion leading to an out-of-bounds load

Dieses Codierungsmuster umfasst den Fall, in denen eine Verwechslung spekulative Typ dazu führen kann, ein außerhalb des gültigen Bereichs oder Feldzugriff, in dem der geladene Wert eine Adresse für nachfolgende Feeds, Typ verwechselt.This coding pattern involves the case where a speculative type confusion can result in an out-of-bounds or type-confused field access where the loaded value feeds a subsequent load address. Dieser Vorgang das Schreiben von Code außerhalb des gültigen Bereichs Arraymuster ähnelt, aber es über eine Alternative, die Codierung der Sequenz wie oben gezeigt angezeigt wird.This is similar to the array out-of-bounds coding pattern but it is manifested through an alternative coding sequence as shown above. In diesem Beispiel den Kontext ein angreifenden kann dazu führen, dass Opfer Kontext zum Ausführen ProcessType mehrmals mit einem Objekt vom Typ CType1 (type Feld ist gleich Type1).In this example, an attacking context could cause the victim context to execute ProcessType multiple times with an object of type CType1 (type field is equal to Type1). Dies hat den Effekt des Trainings für des bedingten Branch für die erste if -Anweisung nicht die Vorhersagen.This will have the effect of training the conditional branch for the first if statement to predict not taken. Angreifende Kontext kann bewirken, dass den Opfer Kontext zum Ausführen ProcessType mit einem Objekt vom Typ CType2.The attacking context can then cause the victim context to execute ProcessType with an object of type CType2. Dies kann in einer Verwirrung spekulative Typ führen, wenn der bedingte Ausdruck für die erste Verzweigung if Anweisung falsch vorhergesagte zugeordnet, und führt den Hauptteil des der if -Anweisung, daher Umwandlung eines Objekts vom Typ CType2 zu CType1.This can result in a speculative type confusion if the conditional branch for the first if statement mispredicts and executes the body of the if statement, thus casting an object of type CType2 to CType1. Da CType2 ist kleiner als CType1, die Arbeitsspeicher-Zugriff auf CType1::field2 führen zu einer spekulativen außerhalb des gültigen Bereichs lädt Daten, die geheim sein kann.Since CType2 is smaller than CType1, the memory access to CType1::field2 will result in a speculative out-of-bounds load of data that may be secret. Dieser Wert wird dann verwendet, bei einem Auslastungstest aus shared_buffer können die wahrnehmbaren Nebeneffekte, wie mit dem Array erstellen außerhalb des gültigen Bereichs Beispiel oben beschriebenen.This value is then used in a load from shared_buffer which can create observable side effects, as with the array out-of-bounds example described previously.

Spekulative Typ zu Verwirrung führt zu einer indirekten VerzweigungSpeculative type confusion leading to an indirect branch

Dieses Codierungsmuster umfasst den Fall, in denen eine Verwechslung spekulative Typ einer unsicheren indirekte Verzweigung während der spekulativen Ausführung führen kann.This coding pattern involves the case where a speculative type confusion can result in an unsafe indirect branch during speculative execution. In diesem Beispiel den Kontext ein angreifenden kann dazu führen, dass Opfer Kontext zum Ausführen ProcessType mehrmals mit einem Objekt vom Typ CType2 (type Feld ist gleich Type2).In this example, an attacking context could cause the victim context to execute ProcessType multiple times with an object of type CType2 (type field is equal to Type2). Dies hat den Effekt des Trainings für des bedingten Branch für die erste if Anweisung an, die ausgeführt werden und die else if -Anweisung nicht ausgeführt werden.This will have the effect of training the conditional branch for the first if statement to be taken and the else if statement to be not taken. Angreifende Kontext kann bewirken, dass den Opfer Kontext zum Ausführen ProcessType mit einem Objekt vom Typ CType1.The attacking context can then cause the victim context to execute ProcessType with an object of type CType1. Dies kann in einer Verwirrung spekulative Typ führen, wenn der bedingte Ausdruck für die erste Verzweigung if Anweisung vorhersagt ausgeführt und die else if den Text der Anweisung nicht ausgeführt wird, vorhersagt somit Ausführen der else if und ein Objekt des Typs umwandelnCType1 zu CType2.This can result in a speculative type confusion if the conditional branch for the first if statement predicts taken and the else if statement predicts not taken, thus executing the body of the else if and casting an object of type CType1 to CType2. Da die CType2::dispatch_routine Feld überschneidet sich mit den char Array CType1::field1, könnte dies in einer spekulativen indirekte Verzweigung, um eine unbeabsichtigte Verzweigungsziel.Since the CType2::dispatch_routine field overlaps with the char array CType1::field1, this could result in a speculative indirect branch to an unintended branch target. Wenn der angreifende Kontext der Bytewerte in steuern kann die CType1::field1 Array ist, sie können möglicherweise die Zieladresse für den Branch zu steuern.If the attacking context can control the byte values in the CType1::field1 array, they may be able to control the branch target address.

Spekulative nicht initialisierten verwendenSpeculative uninitialized use

Diese Kategorie von Codemuster umfasst Szenarien, in denen spekulativer Ausführung möglicherweise nicht initialisierten Speicher zugreifen und verwenden Sie es in nachfolgenden auslastungs- oder indirekte Branch.This category of coding patterns involves scenarios where speculative execution may access uninitialized memory and use it to feed a subsequent load or indirect branch. Für diese Codierungsmuster für die ausgenutzt werden muss ein Angreifer in der Lage, um zu steuern oder beeinflussen sinnvoll, den Inhalt des Arbeitsspeichers, der verwendet wird, ohne Initialisierung durch den Kontext an, dem sie in verwendet wird.For these coding patterns to be exploitable, an attacker needs to be able to control or meaningfully influence the contents of the memory that is used without being initialized by the context that it is being used in.

Spekulative nicht initialisierten verwenden, was zu einer außerhalb des gültigen Bereichs geladenSpeculative uninitialized use leading to an out-of-bounds load

Spekulative nicht initialisierte Verwendung kann führt möglicherweise zu einer außerhalb des gültigen Bereichs zu laden, indem ein Angreifer gesteuerte-Wert.A speculative uninitialized use can potentially lead to an out-of-bounds load using an attacker controlled value. Im folgenden Beispiel wird der Wert des index erhält trusted_index in allen Architektur Pfaden und trusted_index wird als kleiner als oder gleich buffer_size.In the example below, the value of index is assigned trusted_index on all architectural paths and trusted_index is assumed to be less than or equal to buffer_size. Je nach den Code, der vom Compiler erzeugten, es ist jedoch möglich, dass eine Umgehung spekulative Speicher auftreten kann, die die Last für ermöglicht buffer[index] und abhängigen Ausdrücken zum Ausführen vor der Zuweisung zu index.However, depending on the code produced by the compiler, it is possible that a speculative store bypass may occur that allows the load from buffer[index] and dependent expressions to execute ahead of the assignment to index. In diesem Fall einen nicht initialisierten Wert für index verwendet werden, als der Offset in buffer der Angreifer könnten vertrauliche Informationen außerhalb des gültigen Bereichs, und übermittelt dies über einen Kanal Seite über die abhängige Last shared_buffer .If this occurs, an uninitialized value for index will be used as the offset into buffer which could enable an attacker to read sensitive information out-of-bounds and convey this through a side channel through the dependent load of shared_buffer.

// A pointer to a shared memory region of size 1MB (256 * 4096)
unsigned char *shared_buffer;

void InitializeIndex(unsigned int trusted_index, unsigned int *index) {
    *index = trusted_index;
}

unsigned char ReadByte(unsigned char *buffer, unsigned int buffer_size, unsigned int trusted_index) {
    unsigned int index;

    InitializeIndex(trusted_index, &index); // not inlined

    // SPECULATION BARRIER
    unsigned char value = buffer[index];
    return shared_buffer[value * 4096];
}

Spekulative nicht initialisierten verwenden, was zu einer indirekten VerzweigungSpeculative uninitialized use leading to an indirect branch

Eine spekulative nicht initialisierte Verwendung kann potenziell zur eine indirekte Branch führen, in denen das Verzweigungsziel ist von einem Angreifer gesteuert.A speculative uninitialized use can potentially lead to an indirect branch where the branch target is controlled by an attacker. Im folgenden Beispiel wird routine wird zugewiesen, entweder DefaultMessageRoutine1 oder DefaultMessageRoutine abhängig vom Wert mode.In the example below, routine is assigned to either DefaultMessageRoutine1 or DefaultMessageRoutine depending on the value of mode. Auf dem Architektur-Pfad, führt dies zu routine immer vor dem indirekten Branch initialisiert wird.On the architectural path, this will result in routine always being initialized ahead of the indirect branch. Je nach den Code, der vom Compiler erzeugten, eine Umgehung spekulative Store kann jedoch auftreten, die über die indirekte Verzweigung ermöglicht routine spekulativer vor der Zuweisung zu auszuführende routine.However, depending on the code produced by the compiler, a speculative store bypass may occur that allows the indirect branch through routine to be speculatively executed ahead of the assignment to routine. In diesem Fall ein Angreifer möglicherweise spekulativer führen Sie über eine beliebige Adresse, sofern der Angreifer beeinflussen kann, oder kontrollieren den nicht initialisierten Wert routine.If this occurs, an attacker may be able to speculatively execute from an arbitrary address, assuming the attacker can influence or control the uninitialized value of routine.

#define MAX_MESSAGE_ID 16

typedef void (*MESSAGE_ROUTINE)(unsigned char *buffer, unsigned int buffer_size);

const MESSAGE_ROUTINE DispatchTable[MAX_MESSAGE_ID];
extern unsigned int mode;

void InitializeRoutine(MESSAGE_ROUTINE *routine) {
    if (mode == 1) {
        *routine = &DefaultMessageRoutine1;
    }
    else {
        *routine = &DefaultMessageRoutine;
    }
}

void DispatchMessage(unsigned int untrusted_message_id, unsigned char *buffer, unsigned int buffer_size) {
    MESSAGE_ROUTINE routine;

    InitializeRoutine(&routine); // not inlined

    // SPECULATION BARRIER
    routine(buffer, buffer_size);
}

MigrationsoptionenMitigation options

Spekulative Ausführung Seite ausführungsseitigen channelsicherheitsanfälligkeiten können durch Änderungen an den Quellcode verringert werden.Speculative execution side channel vulnerabilities can be mitigated by making changes to source code. Diese Änderungen können umfassen Beheben von bestimmten Instanzen einer Sicherheitsanfälligkeit, z. B. durch Hinzufügen einer spekulationsbarriere, oder durch Änderungen am Entwurf einer Anwendung sensiblen Informationen für spekulative Sperren die Ausführung.These changes can involve mitigating specific instances of a vulnerability, such as by adding a speculation barrier, or by making changes to the design of an application to make sensitive information inaccessible to speculative execution.

Spekulationsbarriere über manuelle InstrumentierungSpeculation barrier via manual instrumentation

Ein spekulationsbarriere manuell von einem Entwickler, um zu verhindern, dass bei der spekulativen Ausführung fortgesetzt, die entlang eines Pfads ohne architektonische eingefügt werden kann.A speculation barrier can be manually inserted by a developer to prevent speculative execution from proceeding along a non-architectural path. Beispielsweise kann ein Entwickler eine spekulationsbarriere vor einem riskantes Codierungsmuster einfügen, im Hauptteil einen bedingten Block ein, entweder am Anfang des Blocks (nachdem Sie den bedingten Branch) oder vor dem ersten Laden, die relevant ist.For example, a developer can insert a speculation barrier before a dangerous coding pattern in the body of a conditional block, either at the beginning of the block (after the conditional branch) or before the first load that is of concern. Dadurch wird verhindert, dass eine bedingte Verzweigung Misprediction aus den gefährlichen Code serialisieren Sie die Ausführung auf einem nicht-Architektur Pfad ausführen.This will prevent a conditional branch misprediction from executing the dangerous code on a non-architectural path by serializing execution. Spekulatives Barriere Sequenz unterscheidet sich von der Hardware-Architektur, wie in der folgenden Tabelle beschrieben:The speculation barrier sequence differs by hardware architecture as described by the following table:

ArchitekturArchitecture Systeminterne für CVE-2017-5753 spekulationsbarriereSpeculation barrier intrinsic for CVE-2017-5753 Systeminterne für CVE-2018-3639 spekulationsbarriereSpeculation barrier intrinsic for CVE-2018-3639
x86/x64x86/x64 _mm_lfence()_mm_lfence() _mm_lfence()_mm_lfence()
ARMARM aktuell nicht verfügbarnot currently available __dsb(0)__dsb(0)
ARM64ARM64 aktuell nicht verfügbarnot currently available __dsb(0)__dsb(0)

Z. B. den folgenden Code, Muster kann behoben werden, mithilfe der _mm_lfence systeminterne wie unten dargestellt.For example, the following code pattern can be mitigated by using the _mm_lfence intrinsic as shown below.

// A pointer to a shared memory region of size 1MB (256 * 4096)
unsigned char *shared_buffer;

unsigned char ReadByte(unsigned char *buffer, unsigned int buffer_size, unsigned int untrusted_index) {
    if (untrusted_index < buffer_size) {
        _mm_lfence();
        unsigned char value = buffer[untrusted_index];
        return shared_buffer[value * 4096];
    }
}

Spekulationsbarriere über Compiler-Time-instrumentationSpeculation barrier via compiler-time instrumentation

Microsoft C++ -Compiler in Visual Studio 2017 (ab Version 15.5.5) bietet Unterstützung für die /Qspectre fügt automatisch eine spekulationsbarriere für einen begrenzten Satz von potenziell anfällige Codierungsmuster-Schalter im Zusammenhang mit CVE-2017-5753.The Microsoft C++ compiler in Visual Studio 2017 (starting with version 15.5.5) includes support for the /Qspectre switch which automatically inserts a speculation barrier for a limited set of potentially vulnerable coding patterns related to CVE-2017-5753. Die Dokumentation für die "/ qspectre" Flag enthält weitere Informationen zu dessen Auswirkungen und Nutzung.The documentation for the /Qspectre flag provides more information on its effects and usage. Es ist wichtig zu beachten, dass dieses Flag nicht alle der potenziell anfällige Codierungsmuster deckt und als solche Entwickler nicht darauf als eine umfassende Lösung für diese Klasse von Sicherheitsrisiken basieren sollten.It is important to note that this flag does not cover all of the potentially vulnerable coding patterns and as such developers should not rely on it as a comprehensive mitigation for this class of vulnerabilities.

Maskieren von ArrayindizesMasking array indices

In Fällen, in denen außerhalb des gültigen Bereichs ein Spekulatives Laden, kann auftreten, der Arrayindex stark auf die Architektur und nicht-Architektur Pfad umschlossen werden kann durch Hinzufügen der Logik, um den Index des Arrays explizit gebunden.In cases where a speculative out-of-bounds load may occur, the array index can be strongly bounded on both the architectural and non-architectural path by adding logic to explicitly bound the array index. Z. B. wenn ein Array auf eine Größe zugewiesen werden kann, die in eine Potenz von zwei ausgerichtet ist, können Sie dann eine einfache Maske eingeführt werden.For example, if an array can be allocated to a size that is aligned to a power of two, then a simple mask can be introduced. Dies wird veranschaulicht, in das folgende Beispiel, in denen es davon, dass ausgegangen wird buffer_size eine Potenz von zwei ausgerichtet ist.This is illustrated in the sample below where it is assumed that buffer_size is aligned to a power of two. Dadurch wird sichergestellt, dass untrusted_index ist immer kleiner als buffer_size, auch wenn eine bedingte Verzweigung Misprediction tritt ein, und untrusted_index übergebene mit einem Wert größer als oder gleich buffer_size.This ensures that untrusted_index is always less than buffer_size, even if a conditional branch misprediction occurs and untrusted_index was passed in with a value greater than or equal to buffer_size.

Es sollte darauf hingewiesen werden, dass die Index-Maske, die hier ausgeführt unterliegt spekulative Store umgehen, je nach Code könnte, die vom Compiler generiert wird.It should be noted that the index masking performed here could be subject to speculative store bypass depending on the code that is generated by the compiler.

// A pointer to a shared memory region of size 1MB (256 * 4096)
unsigned char *shared_buffer;

unsigned char ReadByte(unsigned char *buffer, unsigned int buffer_size, unsigned int untrusted_index) {
    if (untrusted_index < buffer_size) {
        untrusted_index &= (buffer_size - 1);
        unsigned char value = buffer[untrusted_index];
        return shared_buffer[value * 4096];
    }
}

Vertraulichen Informationen entfernt aus dem Arbeitsspeicher.Removing sensitive information from memory

Ein weiteres Verfahren, das zum Verringern von Sicherheitsrisiken in spekulativer Ausführung Seite Channel verwendet werden kann ist, vertrauliche Informationen aus dem Arbeitsspeicher zu entfernen.Another technique that can be used to mitigate speculative execution side channel vulnerabilities is to remove sensitive information from memory. Software-Entwickler können Suchen Sie nach Möglichkeiten, ihre Anwendung Umgestalten, dass der Zugriff auf vertraulicher Informationen während der spekulativen Ausführung nicht zugänglich ist.Software developers can look for opportunities to refactor their application such that sensitive information is not accessible during speculative execution. Dies kann durch den Entwurf einer Anwendung zum Isolieren von vertraulichen Informationen in separaten Prozessen refactoring erfolgen.This can be accomplished by refactoring the design of an application to isolate sensitive information into separate processes. Beispielsweise kann eine Web-Browser-Anwendung versuchen, um die Daten, die jeder Web-Ursprung in separate Prozesse, daher verhindert, dass ein Prozess kann für Cross-Origin-Datenzugriff durch spekulative Ausführung zugeordnet zu isolieren.For example, a web browser application can attempt to isolate the data associated with each web origin into separate processes, thus preventing one process from being able to access cross-origin data through speculative execution.

Siehe auchSee also

Anleitungen zum Verringern von Sicherheitsrisiken in seitenkanalangriffe mit spekulativer AusführungGuidance to mitigate speculative execution side-channel vulnerabilities
Beheben von Sicherheitsrisiken durch spekulative Ausführung Seite Kanal hardwareMitigating speculative execution side channel hardware vulnerabilities