Wie konsistent SHA1 von Festplatte oder Band zu erhalten, die EWF aktiviert ist (Win 7 embedded)

Question

Problem: Ich bin nicht in der Lage reproduzierbare Datei, Volumen oder sogar physisches Laufwerk Hashes (zB SHA1) zu erhalten, auch mit EWF aktiviert auf Win 7 Embedded und Verwendung der CreateFile/ReadFile-Methoden der Win32-API. Es scheint (für mich), dass ReadFile von der EWF-RAM-Overlay liest, aber ich brauche es, um die Bytes von der Festplatte zu bekommen.

Hintergrund: Wir aktualisieren eine regulierte Hardware + Software von Windows XP Embedded (FAT32) auf Windows 7 Embedded (NTFS). Der Anwendungscode ist in C# .Net und VC++ geschrieben.

Eine regulatorische Anforderung besteht darin, überprüfen zu können, dass alle auf der Festplatte vorhandenen Dateien einschließlich der Betriebssystemdateien exakte Kopien der Referenzdateien sind, die dem Regulator übergeben wurden. Der Regler muss in der Lage sein, diese Verifizierung durchzuführen, während das Hardwaregerät funktionsfähig ist (in Produktion), ohne die auf dem Gerät laufenden Anwendungen zu stoppen.

In den Tagen von XP Embedded konnten wir konsistente Datei-Hashes erhalten, wenn EWF aktiviert war und das Gerät funktionierte, indem das FAT32-Dateisystem analysiert und Festplatten-Cluster über ReadFile gelesen wurden (Win 32 API, kernel32.dll) . Die Hashes waren nicht konsistent, wenn wir die Datei zum Beispiel als FileStream lesen.

Unsere Betriebssysteme und Anwendungen werden als unveränderbares Master Disk Image bereitgestellt. Wir klonen die Festplatten von einem Master mit einer Byte-für-Laufwerk-Klon-Hardware. Wir haben auch das Klonen über OSFClone (dd) unter Linux durchgeführt.

Wir versuchen, dies zu reproduzieren (d. H. Verifizierbar Datei Hashes) in Windows 7 Embedded (x64), die eine NTFS-Partition für das Betriebssystem erfordert. Umwelt

Test:

• Betriebssystem Windows Embedded Standard 7 EWF im RAM-Modus auf unseren Volumes aktiviert (C :, D :)
• NTFSLastAccessUpdate eingestellt wurde auf "1" in die Registrierung unter SYSTEM \ Control \
• All Bootstat.dat Dateien wurden aus dem Laufwerk vor der Aktivierung von EWF und die Änderungen über ewfmgr

begangen gelöscht Zuvor

, zu prüfen, ob der Antrieb unveränderlich ist, ich habe folgendes getan:

• Stiefel ein Gerät mit der Win 7e Laufwerk und Abschaltung nach Änderungen (EWF aktiviert)
• Stecken Sie das Win7e Festplatte in einem Kali Linux System und benutze dd | sha1sum, um den Hash des gesamten Laufwerks zu erhalten
• Schließen Sie das Win7e-Laufwerk im Gerät und starten Sie, nehmen Sie Änderungen (EWF aktiviert) und wiederholen Sie die dd | sha1sum Schritt auf Kali Linux wieder (z. B. dd if =/dev/sda1 | sha1sum) wobei/dev/sda1 ist eine EWF-geschützte Windows-Partition .

Die Signaturen in diesem Test zwischen verschiedenen Booten abgestimmt. Ich führe den Test oben nochmal durch, aber es dauert eine Weile. [Edit: Ich habe den Test jetzt erneut ausgeführt: der EWF funktioniert und Linux gibt genau die gleichen Hashes für/dev/sda1 zwischen den Neustarts des Win7e-Laufwerks zurück].NTFSLib und der Testcode, die unten eingefügt werden, reproduzieren die gleichen Signaturen des EWF-geschützten Laufwerks nicht.

Problem: wir versucht haben, sowie eine „NtfsLib“ (https://github.com/LordMike/NtfsLib) Create/ReadFile- Methoden einzelne Dateien, Datenträger zu lesen und \ \ PhysicalDriveN aber wir sind nicht reproduzierbar Hashes zwischen Neustarts der bekommen. Gerät. Das heißt, wir erhalten jedes Mal einen anderen SHA1-Hash für eine Windows-Datei (C: \ windows \ windowsupdate.log); Wir bekommen verschiedene Hashes für \. \ C: jedes Mal, und wir erhalten jedes Mal verschiedene Hashes für \. \ PhysicalDrive0.

Ich füge den C# -Code darunter, den ich benutze, um Signaturen zu berechnen. Es macht mir nichts aus, das Ding in eine andere Sprache zu schreiben, etwa C oder C++, solange ich rohe Bytes von der Festplatte bekomme. Bitte sagen Sie mir, wenn ich beim Lesen von Rohbytes etwas falsch mache. Ich muss nicht einzelne Dateien per se lesen und hashen. Ich kann die gesamte Festplatte oder ein gesamtes Volume lesen und hashen, solange der Hash zwischen den Neustarts des Geräts übereinstimmt. Das Hacken des gesamten Laufwerks oder des Volumens würde die gesetzlichen Anforderungen erfüllen. Für mich scheinen die Bytes, die ich von ReadFile erhalte, EWFs Ansicht des Dateisystems zu zeigen.

Ich würde mich über Hinweise freuen, die mir jemand geben kann. Ich habe verschiedene Beiträge über ReadFile gelesen, aber keine Hinweise auf dieses Verhalten mit EWF gefunden.

Ich führe den Code unten als Admin unter Windows und meine app.manifest hat die requireAdmin-Sache gesetzt.

using System; 
using System.Runtime.InteropServices; 
using System.Security.Cryptography; 
using Microsoft.Win32.SafeHandles; 


namespace CSharpReadDisk 
{ 
    class DiskReader 
    { 
     public const uint GenericRead = 0x80000000; 
     public const uint FileShareRead = 1; 
     public const uint FileShareWrite = 2; 
     public const uint OpenExisting = 3; 

     [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)] 
     static extern unsafe IntPtr CreateFile(string lpFileName, uint dwDesiredAccess, 
      uint dwShareMode, IntPtr lpSecurityAttributes, uint dwCreationDisposition, 
      uint dwFlagsAndAttributes, IntPtr hTemplateFile); 

     [DllImport("kernel32.dll", SetLastError = true)] 
     static extern unsafe bool ReadFile(IntPtr hFile, void* lpBuffer, 
      uint nNumberOfBytesToRead, uint* lpNumberOfBytesRead, IntPtr lpOverlapped); 

     [DllImport("kernel32", SetLastError = true)] 
     static extern unsafe bool CloseHandle(IntPtr hObject); 


     public unsafe IntPtr Open(string filename) 
     { 
      // open the existing file for reading  
      IntPtr handle = CreateFile(filename, GenericRead, FileShareRead | FileShareWrite, IntPtr.Zero, OpenExisting, 0, IntPtr.Zero); 
      return handle; 
     } 

     public unsafe uint Read(IntPtr handle, byte[] buffer, uint count) 
     { 
      uint n = 0; 
      fixed (byte* p = buffer) 
      { 
       if (!(ReadFile(handle, p, count, &n, IntPtr.Zero))) 
       { 
        return 0; 
       } 
      } 
      return n; 
     } 

     public unsafe bool Close(IntPtr handle) 
     { 
      return CloseHandle(handle); 
     } 
    } 

    class Test 
    { 
     static void Main(string[] args) 
     { 
      DiskReader dr = new DiskReader(); 

      Console.Write("Enter path to drive, volume or file: "); 
      string path = Console.ReadLine(); 
      IntPtr fh = dr.Open(path); 

      try 
      { 
       SafeFileHandle sfh = new SafeFileHandle(fh, true); 
       if (sfh.IsInvalid) 
       { 
        Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); 
       } 

       Console.WriteLine("Enter read buffer size (MB): "); 
       int bs = Console.Read(); 

       byte[] lpBuffer = new byte[bs * 1024 * 1024]; 

       uint bytesRead = 0; 
       SHA1Managed sha1 = new SHA1Managed(); 
       while ((bytesRead = dr.Read(fh, lpBuffer, (uint)lpBuffer.Length)) > 0) 
       { 
        sha1.TransformBlock(lpBuffer, 0, (int)bytesRead, null, 0); 
        Console.Write("."); 
       } 
       sha1.TransformFinalBlock(lpBuffer, 0, (int)bytesRead); 
       Console.WriteLine("\nSHA1: {0}", BitConverter.ToString(sha1.Hash)); 
      } 
      catch (Exception e) 
      { 
       Console.WriteLine("An exception occurred:\n HResult: {0}\n Message: {1}\n InnerException: {2}\n Source: {3}\n TargetSite: {4}\n StackTrace: {5}", 
        e.HResult, e.Message, e.InnerException, e.Source, e.TargetSite, e.StackTrace); 
      } 
      dr.Close(fh); // close filehandle 


      Console.WriteLine("\nPress any key to exit..."); 
      Console.ReadKey(); 
     } 
    } 
} 

Answer 1

Update für jeden, der interessiert ist, können Sie tatsächlich unter EWF über CreateFile/ReadFile von Win32 API gehen. Sie müssen das Handle \. \ PhysicalDriveN verwenden und dann bestimmte Bytes lesen, die dem Volume entsprechen, an dem Sie interessiert sind. Dazu können Sie die SetFilePointer-Funktion verwenden, die auch von der Win32-API bereitgestellt wird. Wenn Sie das gesamte Laufwerk hashen möchten, müssen Sie natürlich keine spezifischen Bytes lesen, die dem Volume entsprechen. MSDN-Dokumente zu diesem Thema sind nicht sehr klar und die Dokumente berücksichtigen nicht den spezifischen EWF-Anwendungsfall.