RtlCopyVolatileMemory-Funktion (wdm.h)
Die RtlCopyVolatileMemory-Funktion bietet RtlCopyMemory-Verhalten (z. B. Kopieren von Speicher von einem Speicherort an einen anderen) in Situationen, in denen der Entwickler sicher sein muss, dass der Kopiervorgang erfolgt (z. B. keine Compileroptimierungen unterliegt).
Syntax
volatile void * RtlCopyVolatileMemory(
[out] volatile void *Destination,
[in] volatile const void *Source,
[in] size_t Length
);
Parameter
[out] Destination
Ein Zeiger auf die Startadresse des Ziels des kopierten Blocks.
[in] Source
Ein Zeiger auf die Startadresse des zu kopierenden Speicherblocks.
[in] Length
Die Größe des zu kopierenden Speicherblocks in Bytes.
Rückgabewert
Gibt den Wert von Destination zurück.
Hinweise
Die RtlCopyVolatileMemory-Funktion verfügt über die folgenden Eigenschaften:
Die Funktion wird nicht als intrinsischer Compiler erkannt, sodass der Compiler den Aufruf niemals optimiert (entweder vollständig oder ersetzt den Aufruf durch eine entsprechende Abfolge von Anweisungen). Dies unterscheidet sich von RtlCopyMemory , das verschiedenen Compileroptimierungen unterliegt.
Wenn der Aufruf zurückgibt, wurden die Daten von Quelle in Ziel kopiert. Mit dieser Funktion werden Speicherzugriffe auf die Quelle und das Ziel nur innerhalb der Funktion ausgeführt (z. B. kann der Compiler speicherzugriffe nicht aus dieser Funktion verschieben).
Die Funktion kann nicht ausgerichtete Speicherzugriffe ausführen, wenn die Plattform dies zulässt.
Die Funktion kann im Rahmen ihres Kopiervorgangs mehrmals auf Speicherspeicherorte zugreifen.
Es ähnelt RtlCopyMemory insofern, als es keine Kopiervorgänge unterstützt, wenn Sich Quelle und Ziel überlappen.
Hinweis
Diese Funktion funktioniert für alle Versionen von Windows, nicht nur für die neuesten Versionen. Sie müssen den neuesten WDK nutzen, um die Funktionsdeklaration aus dem wdm.h-Header abzurufen. Sie benötigen auch die Bibliothek (volatileaccessk.lib) aus dem neuesten WDK. Der resultierende Treiber wird jedoch unter älteren Versionen von Windows einwandfrei ausgeführt.
Beispiel
HEADER MyHeader;
UCHAR RawBuffer[100];
// Ensure that the shared memory (which could be constantly changing)
// is copied in to the local MyHeader variable.
// Note that the compiler is allowed to optimize away calls to
// RtlCopyMemory so those functions are not guaranteed to actually
// make a local copy of data.
//
// RtlCopyVolatileMemory does not handle a source/dest buffer that overlap
// with each other (RtlCopyMemory semantics).
//
// Assume SharedMemory points to virtual memory that is also mapped in an untrusted process.
// Assume that untrusted process is changing the memory contents while you are accessing it.
PVOID SharedMemory;
RtlCopyVolatileMemory(&MyHeader, SharedMemory, sizeof(MyHeader));
if (MyHeader.Size < 100) {
// Because MyHeader is local and we are guaranteed we actually made
// a local copy, we can be sure that the "Size" value will not change
// between the previous bounds check and the below call to RtlFillMemory.
// If RtlCopyMemory had been used to copy the data, it is possible
// that a compiler may optimize away the call to RtlCopyMemory and instead fetch
// the "size" field of MyHeader directly from untrusted memory two times.
// The first time it would be fetched for the bounds check, and the second
// time it is fetched is for the call to RtlFillMemory. It is possible the memory
// could have changed between the two accesses resulting in the size check
// being ineffective.
RtlFillMemory (RawBuffer, MyHeader.Size, 0);
}
Anforderungen
| Anforderung | Wert |
|---|---|
| Header | wdm.h (wdm.h einschließen) |
| Bibliothek | volatileaccessk.lib (Kernelmodus), volatileaccessu.lib (Benutzermodus) |