From 3c8eec038cc6ec1e0eea4b0e634cfcaccf33459f Mon Sep 17 00:00:00 2001
From: Isaac Marovitz <isaacryu@icloud.com>
Date: Fri, 27 Oct 2023 14:46:30 -0400
Subject: [PATCH] Use a FileHandle instead of loading whole PE

---
 Whisky/Models/Bottle.swift                |   4 +-
 WhiskyKit/Extensions/DataExtensions.swift |  33 ++---
 WhiskyKit/PE/BitmapInfo.swift             |  54 ++++----
 WhiskyKit/PE/PortableExecutable.swift     | 150 ++++++++++++----------
 WhiskyKit/PE/ResourceSection.swift        |  60 +++++----
 WhiskyKit/PE/ShellLink.swift              |  52 ++++----
 WhiskyKit/Whisky/Program.swift            |   2 +-
 WhiskyThumbnail/ThumbnailProvider.swift   |   2 +-
 8 files changed, 182 insertions(+), 175 deletions(-)

diff --git a/Whisky/Models/Bottle.swift b/Whisky/Models/Bottle.swift
index 0d05f0e24..2cb5ef5c5 100644
--- a/Whisky/Models/Bottle.swift
+++ b/Whisky/Models/Bottle.swift
@@ -68,7 +68,9 @@ extension Bottle {
 
         for link in linkURLs {
             do {
-                if let program = ShellLinkHeader.getProgram(url: link, data: try Data(contentsOf: link), bottle: self) {
+                if let program = ShellLinkHeader.getProgram(url: link,
+                                                            handle: try FileHandle(forReadingFrom: link),
+                                                            bottle: self) {
                     if !startMenuPrograms.contains(where: { $0.url == program.url }) {
                         startMenuPrograms.append(program)
                         try FileManager.default.removeItem(at: link)
diff --git a/WhiskyKit/Extensions/DataExtensions.swift b/WhiskyKit/Extensions/DataExtensions.swift
index c981ac56c..4e46ae2d3 100644
--- a/WhiskyKit/Extensions/DataExtensions.swift
+++ b/WhiskyKit/Extensions/DataExtensions.swift
@@ -18,34 +18,17 @@
 
 import Foundation
 
-extension Data {
+extension FileHandle {
     public func extract<T>(_ type: T.Type, offset: Int = 0) -> T? {
-        if offset + MemoryLayout<T>.size < self.count {
-            let data = self[offset..<offset + MemoryLayout<T>.size]
-            return data.withUnsafeBytes { $0.loadUnaligned(as: T.self) }
-        } else {
+        do {
+            try self.seek(toOffset: UInt64(offset))
+            if let data = try self.read(upToCount: MemoryLayout<T>.size) {
+                return data.withUnsafeBytes { $0.loadUnaligned(as: T.self)}
+            }
+        } catch {
             return nil
         }
-    }
 
-    // Thanks ChatGPT
-    public func nullTerminatedStrings(using encoding: String.Encoding = .utf8) -> [String] {
-        var strings = [String]()
-        self.withUnsafeBytes { (ptr: UnsafeRawBufferPointer) in
-            if let baseAddress = ptr.baseAddress {
-                var strStart = baseAddress
-                let strEnd = baseAddress + self.count
-                while strStart < strEnd {
-                    let strPtr = strStart.assumingMemoryBound(to: CChar.self)
-                    let strLen = strnlen(strPtr, self.count)
-                    let strData = Data(bytes: strPtr, count: strLen)
-                    if let str = String(data: strData, encoding: encoding) {
-                        strings.append(str)
-                    }
-                    strStart = strStart.advanced(by: strLen + 1)
-                }
-            }
-        }
-        return strings
+        return nil
     }
 }
diff --git a/WhiskyKit/PE/BitmapInfo.swift b/WhiskyKit/PE/BitmapInfo.swift
index ed8b5c0f3..e19626bd6 100644
--- a/WhiskyKit/PE/BitmapInfo.swift
+++ b/WhiskyKit/PE/BitmapInfo.swift
@@ -35,29 +35,29 @@ public struct BitmapInfoHeader: Hashable {
     public let originDirection: BitmapOriginDirection
     public let colorFormat: ColorFormat
 
-    init(data: Data, offset: Int) {
+    init(handle: FileHandle, offset: Int) {
         var offset = offset
-        self.size = data.extract(UInt32.self, offset: offset) ?? 0
+        self.size = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.width = data.extract(Int32.self, offset: offset) ?? 0
+        self.width = handle.extract(Int32.self, offset: offset) ?? 0
         offset += 4
-        self.height = data.extract(Int32.self, offset: offset) ?? 0
+        self.height = handle.extract(Int32.self, offset: offset) ?? 0
         offset += 4
-        self.planes = data.extract(UInt16.self, offset: offset) ?? 0
+        self.planes = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.bitCount = data.extract(UInt16.self, offset: offset) ?? 0
+        self.bitCount = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.compression = BitmapCompression(rawValue: data.extract(UInt32.self, offset: offset) ?? 0) ?? .rgb
+        self.compression = BitmapCompression(rawValue: handle.extract(UInt32.self, offset: offset) ?? 0) ?? .rgb
         offset += 4
-        self.sizeImage = data.extract(UInt32.self, offset: offset) ?? 0
+        self.sizeImage = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.xPelsPerMeter = data.extract(Int32.self, offset: offset) ?? 0
+        self.xPelsPerMeter = handle.extract(Int32.self, offset: offset) ?? 0
         offset += 4
-        self.yPelsPerMeter = data.extract(Int32.self, offset: offset) ?? 0
+        self.yPelsPerMeter = handle.extract(Int32.self, offset: offset) ?? 0
         offset += 4
-        self.clrUsed = data.extract(UInt32.self, offset: offset) ?? 0
+        self.clrUsed = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.clrImportant = data.extract(UInt32.self, offset: offset) ?? 0
+        self.clrImportant = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
 
         self.originDirection = self.height < 0 ? .upperLeft : .bottomLeft
@@ -65,9 +65,9 @@ public struct BitmapInfoHeader: Hashable {
     }
 
     // swiftlint:disable:next cyclomatic_complexity function_body_length
-    func renderBitmap(data: Data, offset: Int) -> NSImage {
+    func renderBitmap(handle: FileHandle, offset: Int) -> NSImage {
         var offset = offset
-        let colorTable = buildColorTable(offset: &offset, data: data)
+        let colorTable = buildColorTable(offset: &offset, handle: handle)
 
         var pixels: [ColorQuad] = []
 
@@ -91,7 +91,7 @@ public struct BitmapInfoHeader: Hashable {
                     // Ditto .indexed1
                     break
                 case .indexed8:
-                    let index = Int(data.extract(UInt8.self, offset: offset) ?? 0)
+                    let index = Int(handle.extract(UInt8.self, offset: offset) ?? 0)
                     if index >= colorTable.count {
                         pixelRow.append(ColorQuad(red: 0, green: 0, blue: 0, alpha: 0))
                     } else {
@@ -99,7 +99,7 @@ public struct BitmapInfoHeader: Hashable {
                     }
                     offset += 1
                 case .sampled16:
-                    let sample = data.extract(UInt16.self, offset: offset) ?? 0
+                    let sample = handle.extract(UInt16.self, offset: offset) ?? 0
                     let red = sample & 0x001F
                     let green = (sample & 0x03E0) >> 5
                     let blue = (sample & 0x7C00) >> 10
@@ -109,24 +109,24 @@ public struct BitmapInfoHeader: Hashable {
                                             alpha: 1))
                     offset += 2
                 case .sampled24:
-                    let blue = data.extract(UInt8.self, offset: offset) ?? 0
+                    let blue = handle.extract(UInt8.self, offset: offset) ?? 0
                     offset += 1
-                    let green = data.extract(UInt8.self, offset: offset) ?? 0
+                    let green = handle.extract(UInt8.self, offset: offset) ?? 0
                     offset += 1
-                    let red = data.extract(UInt8.self, offset: offset) ?? 0
+                    let red = handle.extract(UInt8.self, offset: offset) ?? 0
                     offset += 1
                     pixelRow.append(ColorQuad(red: red,
                                               green: green,
                                               blue: blue,
                                               alpha: 1))
                 case .sampled32:
-                    let blue = data.extract(UInt8.self, offset: offset) ?? 0
+                    let blue = handle.extract(UInt8.self, offset: offset) ?? 0
                     offset += 1
-                    let green = data.extract(UInt8.self, offset: offset) ?? 0
+                    let green = handle.extract(UInt8.self, offset: offset) ?? 0
                     offset += 1
-                    let red = data.extract(UInt8.self, offset: offset) ?? 0
+                    let red = handle.extract(UInt8.self, offset: offset) ?? 0
                     offset += 1
-                    let alpha = data.extract(UInt8.self, offset: offset) ?? 0
+                    let alpha = handle.extract(UInt8.self, offset: offset) ?? 0
                     offset += 1
                     pixelRow.append(ColorQuad(red: red,
                                               green: green,
@@ -147,15 +147,15 @@ public struct BitmapInfoHeader: Hashable {
         return constructImage(pixels: pixels)
     }
 
-    func buildColorTable(offset: inout Int, data: Data) -> [ColorQuad] {
+    func buildColorTable(offset: inout Int, handle: FileHandle) -> [ColorQuad] {
         var colorTable: [ColorQuad] = []
 
         for _ in 0..<clrUsed {
-            let blue = data.extract(UInt8.self, offset: offset) ?? 0
+            let blue = handle.extract(UInt8.self, offset: offset) ?? 0
             offset += 1
-            let green = data.extract(UInt8.self, offset: offset) ?? 0
+            let green = handle.extract(UInt8.self, offset: offset) ?? 0
             offset += 1
-            let red = data.extract(UInt8.self, offset: offset) ?? 0
+            let red = handle.extract(UInt8.self, offset: offset) ?? 0
             offset += 2
 
             colorTable.append(ColorQuad(red: red,
diff --git a/WhiskyKit/PE/PortableExecutable.swift b/WhiskyKit/PE/PortableExecutable.swift
index cc5668d0d..40fd4235f 100644
--- a/WhiskyKit/PE/PortableExecutable.swift
+++ b/WhiskyKit/PE/PortableExecutable.swift
@@ -36,48 +36,58 @@ public struct PESection: Hashable {
     public let numberOfRelocations: UInt16
     public let numberOfLineNumbers: UInt16
     public let characteristics: UInt32
-    public let data: Data?
+    // public let data: Data?
 
-    init(data: Data, offset: Int) {
+    init?(handle: FileHandle, offset: Int) throws {
         var offset = offset
-        self.name = String(data: data[offset..<offset + 8], encoding: .utf8) ?? ""
+        try handle.seek(toOffset: UInt64(offset))
+        if let nameData = try handle.read(upToCount: 8) {
+            self.name = String(data: nameData, encoding: .utf8) ?? ""
+        } else {
+            self.name = ""
+        }
         offset += 8
-        self.virtualSize = data.extract(UInt32.self, offset: offset) ?? 0
+        self.virtualSize = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.virtualAddress = data.extract(UInt32.self, offset: offset) ?? 0
+        self.virtualAddress = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.sizeOfRawData = data.extract(UInt32.self, offset: offset) ?? 0
+        self.sizeOfRawData = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.pointerToRawData = data.extract(UInt32.self, offset: offset) ?? 0
+        self.pointerToRawData = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.pointerToRelocations = data.extract(UInt32.self, offset: offset) ?? 0
+        self.pointerToRelocations = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.pointerToLineNumbers = data.extract(UInt32.self, offset: offset) ?? 0
+        self.pointerToLineNumbers = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.numberOfRelocations = data.extract(UInt16.self, offset: offset) ?? 0
+        self.numberOfRelocations = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.numberOfLineNumbers = data.extract(UInt16.self, offset: offset) ?? 0
+        self.numberOfLineNumbers = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.characteristics = data.extract(UInt32.self, offset: offset) ?? 0
+        self.characteristics = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        if sizeOfRawData > 0 {
-            let dataOffset = Int(pointerToRawData)
-            self.data = data.subdata(in: dataOffset..<dataOffset+Int(sizeOfRawData))
-        } else {
-            self.data = nil
-        }
+//        if sizeOfRawData > 0 {
+//            let dataOffset = Int(pointerToRawData)
+//            self.data = data.subdata(in: dataOffset..<dataOffset+Int(sizeOfRawData))
+//        } else {
+//            self.data = nil
+//        }
     }
 }
 
 public struct SectionTable: Hashable {
     public let sections: [PESection]
 
-    init(data: Data, offset: Int, numberOfSections: Int) {
+    init(handle: FileHandle, offset: Int, numberOfSections: Int) {
         var sections = [PESection]()
         var offset = offset
         for _ in 0..<numberOfSections {
-            let section = PESection(data: data, offset: offset)
-            sections.append(section)
+            do {
+                if let section = try PESection(handle: handle, offset: offset) {
+                    sections.append(section)
+                }
+            } catch {
+                print("Failed to get section name!")
+            }
             offset += 40
         }
         self.sections = sections
@@ -95,31 +105,31 @@ public struct COFFFileHeader: Hashable {
     public let sectionTable: SectionTable
     public let optionalHeader: OptionalHeader
 
-    init(data: Data) throws {
+    init(handle: FileHandle) throws {
         var offset = 0x3C
-        let peOffset = data.extract(UInt32.self, offset: offset) ?? 0
+        let peOffset = handle.extract(UInt32.self, offset: offset) ?? 0
         offset = Int(peOffset)
 
         offset += 4
-        let machine = data.extract(UInt16.self, offset: offset) ?? 0
+        let machine = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
 
-        let numberOfSections = data.extract(UInt16.self, offset: offset) ?? 0
+        let numberOfSections = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
 
-        let timeDateStamp = data.extract(UInt32.self, offset: offset) ?? 0
+        let timeDateStamp = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
 
-        let pointerToSymbolTable = data.extract(UInt32.self, offset: offset) ?? 0
+        let pointerToSymbolTable = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
 
-        let numberOfSymbols = data.extract(UInt32.self, offset: offset) ?? 0
+        let numberOfSymbols = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
 
-        let sizeOfOptionalHeader = data.extract(UInt16.self, offset: offset) ?? 0
+        let sizeOfOptionalHeader = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
 
-        let characteristics = data.extract(UInt16.self, offset: offset) ?? 0
+        let characteristics = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
 
         self.machine = machine
@@ -130,10 +140,10 @@ public struct COFFFileHeader: Hashable {
         self.sizeOfOptionalHeader = sizeOfOptionalHeader
         self.characteristics = characteristics
 
-        self.optionalHeader = OptionalHeader(data: data, offset: offset)
+        self.optionalHeader = OptionalHeader(handle: handle, offset: offset)
         offset += Int(sizeOfOptionalHeader)
 
-        self.sectionTable = SectionTable(data: data, offset: offset, numberOfSections: Int(numberOfSections))
+        self.sectionTable = SectionTable(handle: handle, offset: offset, numberOfSections: Int(numberOfSections))
     }
 }
 
@@ -170,67 +180,67 @@ public struct OptionalHeader: Hashable {
     public let numberOfRvaAndSizes: UInt32
 
     // swiftlint:disable:next function_body_length
-    init(data: Data, offset: Int) {
+    init(handle: FileHandle, offset: Int) {
         var offset = offset
-        self.magic = data.extract(UInt16.self, offset: offset) ?? 0
+        self.magic = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.majorLinkerVersion = data.extract(UInt8.self, offset: offset) ?? 0
+        self.majorLinkerVersion = handle.extract(UInt8.self, offset: offset) ?? 0
         offset += 1
-        self.minorLinkerVersion = data.extract(UInt8.self, offset: offset) ?? 0
+        self.minorLinkerVersion = handle.extract(UInt8.self, offset: offset) ?? 0
         offset += 1
-        self.sizeOfCode = data.extract(UInt32.self, offset: offset) ?? 0
+        self.sizeOfCode = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.sizeOfInitializedData = data.extract(UInt32.self, offset: offset) ?? 0
+        self.sizeOfInitializedData = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.sizeOfUninitializedData = data.extract(UInt32.self, offset: offset) ?? 0
+        self.sizeOfUninitializedData = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.addressOfEntryPoint = data.extract(UInt32.self, offset: offset) ?? 0
+        self.addressOfEntryPoint = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.baseOfCode = data.extract(UInt32.self, offset: offset) ?? 0
+        self.baseOfCode = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.baseOfData = data.extract(UInt32.self, offset: offset) ?? 0
+        self.baseOfData = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.imageBase = data.extract(UInt32.self, offset: offset) ?? 0
+        self.imageBase = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.sectionAlignment = data.extract(UInt32.self, offset: offset) ?? 0
+        self.sectionAlignment = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.fileAlignment = data.extract(UInt32.self, offset: offset) ?? 0
+        self.fileAlignment = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.majorOperatingSystemVersion = data.extract(UInt16.self, offset: offset) ?? 0
+        self.majorOperatingSystemVersion = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.minorOperatingSystemVersion = data.extract(UInt16.self, offset: offset) ?? 0
+        self.minorOperatingSystemVersion = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.majorImageVersion = data.extract(UInt16.self, offset: offset) ?? 0
+        self.majorImageVersion = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.minorImageVersion = data.extract(UInt16.self, offset: offset) ?? 0
+        self.minorImageVersion = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.majorSubsystemVersion = data.extract(UInt16.self, offset: offset) ?? 0
+        self.majorSubsystemVersion = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.minorSubsystemVersion = data.extract(UInt16.self, offset: offset) ?? 0
+        self.minorSubsystemVersion = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.win32VersionValue = data.extract(UInt32.self, offset: offset) ?? 0
+        self.win32VersionValue = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.sizeOfImage = data.extract(UInt32.self, offset: offset) ?? 0
+        self.sizeOfImage = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.sizeOfHeaders = data.extract(UInt32.self, offset: offset) ?? 0
+        self.sizeOfHeaders = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.checkSum = data.extract(UInt32.self, offset: offset) ?? 0
+        self.checkSum = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.subsystem = data.extract(UInt16.self, offset: offset) ?? 0
+        self.subsystem = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.dllCharacteristics = data.extract(UInt16.self, offset: offset) ?? 0
+        self.dllCharacteristics = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.sizeOfStackReserve = data.extract(UInt32.self, offset: offset) ?? 0
+        self.sizeOfStackReserve = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.sizeOfStackCommit = data.extract(UInt32.self, offset: offset) ?? 0
+        self.sizeOfStackCommit = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.sizeOfHeapReserve = data.extract(UInt32.self, offset: offset) ?? 0
+        self.sizeOfHeapReserve = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.sizeOfHeapCommit = data.extract(UInt32.self, offset: offset) ?? 0
+        self.sizeOfHeapCommit = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.loaderFlags = data.extract(UInt32.self, offset: offset) ?? 0
+        self.loaderFlags = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.numberOfRvaAndSizes = data.extract(UInt32.self, offset: offset) ?? 0
+        self.numberOfRvaAndSizes = handle.extract(UInt32.self, offset: offset) ?? 0
     }
 }
 
@@ -255,7 +265,7 @@ public struct PEFile: Hashable {
     public let coffFileHeader: COFFFileHeader
     public var resourceSection: ResourceSection? {
         do {
-            return try ResourceSection(data: data,
+            return try ResourceSection(handle: handle,
                                        sectionTable: coffFileHeader.sectionTable,
                                        imageBase: coffFileHeader.optionalHeader.imageBase)
         } catch {
@@ -265,17 +275,17 @@ public struct PEFile: Hashable {
     public var architecture: Architecture {
         Architecture(rawValue: coffFileHeader.optionalHeader.magic) ?? .unknown
     }
-    private let data: Data
+    private let handle: FileHandle
 
-    public init(data: Data) throws {
-        self.data = data
+    public init(handle: FileHandle) throws {
+        self.handle = handle
         // Verify it is a PE file by checking for the PE header
-        let offsetToPEHeader = data.extract(UInt32.self, offset: 0x3C) ?? 0
-        let peHeader = data.extract(UInt32.self, offset: Int(offsetToPEHeader))
+        let offsetToPEHeader = handle.extract(UInt32.self, offset: 0x3C) ?? 0
+        let peHeader = handle.extract(UInt32.self, offset: Int(offsetToPEHeader))
         guard peHeader == 0x4550 else {
             throw PEError.invalidPEFile
         }
-        coffFileHeader = try COFFFileHeader(data: data)
+        coffFileHeader = try COFFFileHeader(handle: handle)
     }
 
     public func bestIcon() -> NSImage? {
diff --git a/WhiskyKit/PE/ResourceSection.swift b/WhiskyKit/PE/ResourceSection.swift
index 0ff77eb18..09e599c73 100644
--- a/WhiskyKit/PE/ResourceSection.swift
+++ b/WhiskyKit/PE/ResourceSection.swift
@@ -25,12 +25,12 @@ public struct ResourceDirectoryEntry: Hashable {
     public let offsetToSubdirectory: UInt32
     public let dataIsDirectory: Bool
 
-    init(data: Data, offset: Int) {
+    init(handle: FileHandle, offset: Int) {
         var offset = offset
         // Can be name or ID
-        self.id = data.extract(UInt32.self, offset: offset) ?? 0
+        self.id = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.offsetToData = data.extract(UInt32.self, offset: offset) ?? 0
+        self.offsetToData = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
 
         self.dataIsDirectory = (offsetToData & 0x80000000) != 0
@@ -45,29 +45,35 @@ public struct ResourceDataEntry: Hashable {
     public let reserved: UInt32
     public let icon: NSImage
 
-    init(data: Data, offset: Int, sectionTable: SectionTable) {
+    init(handle: FileHandle, offset: Int, sectionTable: SectionTable) {
         var offset = offset
         var icon = NSImage()
-        self.dataRVA = data.extract(UInt32.self, offset: offset) ?? 0
+        self.dataRVA = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.size = data.extract(UInt32.self, offset: offset) ?? 0
+        self.size = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.codePage = data.extract(UInt32.self, offset: offset) ?? 0
+        self.codePage = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.reserved = data.extract(UInt32.self, offset: offset) ?? 0
+        self.reserved = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
 
         if let offsetToData = ResourceDataEntry.resolveRVA(rva: dataRVA, sectionTable: sectionTable) {
-            let bitmapInfo = BitmapInfoHeader(data: data, offset: Int(offsetToData))
+            let bitmapInfo = BitmapInfoHeader(handle: handle, offset: Int(offsetToData))
             if bitmapInfo.size != 40 {
-                let iconData = data.subdata(in: Int(offsetToData)..<Int(offsetToData + size))
-                if let rep = NSBitmapImageRep(data: iconData) {
-                    icon = NSImage(size: rep.size)
-                    icon.addRepresentation(rep)
+                do {
+                    try handle.seek(toOffset: UInt64(offsetToData))
+                    if let iconData = try handle.read(upToCount: Int(size)) {
+                        if let rep = NSBitmapImageRep(data: iconData) {
+                            icon = NSImage(size: rep.size)
+                            icon.addRepresentation(rep)
+                        }
+                    }
+                } catch {
+                    print("Failed to get icon")
                 }
             } else {
                 if bitmapInfo.colorFormat != .unknown {
-                    icon = bitmapInfo.renderBitmap(data: data,
+                    icon = bitmapInfo.renderBitmap(handle: handle,
                                                    offset: Int(offsetToData + bitmapInfo.size))
                 }
             }
@@ -101,24 +107,24 @@ public struct ResourceDirectoryTable: Hashable {
     public let subtables: [ResourceDirectoryTable]
     public let entries: [ResourceDataEntry]
 
-    init(data: Data,
+    init(handle: FileHandle,
          address: Int,
          offset: Int,
          sectionTable: SectionTable,
          entries: inout [ResourceDataEntry],
          depth: Int = 0) {
         var offset = offset
-        self.characteristics = data.extract(UInt32.self, offset: offset) ?? 0
+        self.characteristics = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.timeDateStamp = data.extract(UInt32.self, offset: offset) ?? 0
+        self.timeDateStamp = handle.extract(UInt32.self, offset: offset) ?? 0
         offset += 4
-        self.majorVersion = data.extract(UInt16.self, offset: offset) ?? 0
+        self.majorVersion = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.minorVersion = data.extract(UInt16.self, offset: offset) ?? 0
+        self.minorVersion = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.numberOfNamedEntries = data.extract(UInt16.self, offset: offset) ?? 0
+        self.numberOfNamedEntries = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
-        self.numberOfIdEntries = data.extract(UInt16.self, offset: offset) ?? 0
+        self.numberOfIdEntries = handle.extract(UInt16.self, offset: offset) ?? 0
         offset += 2
 
         var subtables: [ResourceDirectoryTable] = []
@@ -133,13 +139,13 @@ public struct ResourceDirectoryTable: Hashable {
                 continue
             }
 
-            let entry = ResourceDirectoryEntry(data: data, offset: offset)
+            let entry = ResourceDirectoryEntry(handle: handle, offset: offset)
             offset += 8
             if entry.dataIsDirectory {
                 // In the root directory, we only want to append entries of type icon
                 if depth == 0 {
                     if ResourceTypes(rawValue: entry.id) == .icon {
-                        subtables.append(ResourceDirectoryTable(data: data,
+                        subtables.append(ResourceDirectoryTable(handle: handle,
                                                                      address: address,
                                                                      offset: Int(entry.offsetToSubdirectory) + address,
                                                                      sectionTable: sectionTable,
@@ -147,7 +153,7 @@ public struct ResourceDirectoryTable: Hashable {
                                                                      depth: depth + 1))
                     }
                 } else {
-                    subtables.append(ResourceDirectoryTable(data: data,
+                    subtables.append(ResourceDirectoryTable(handle: handle,
                                                                  address: address,
                                                                  offset: Int(entry.offsetToSubdirectory) + address,
                                                                  sectionTable: sectionTable,
@@ -155,7 +161,7 @@ public struct ResourceDirectoryTable: Hashable {
                                                                  depth: depth + 1))
                 }
             } else {
-                let entry = ResourceDataEntry(data: data,
+                let entry = ResourceDataEntry(handle: handle,
                                               offset: Int(entry.offsetToData) + address,
                                               sectionTable: sectionTable)
                 entries.append(entry)
@@ -180,12 +186,12 @@ public struct ResourceSection: Hashable {
     public let rootDirectoryTable: ResourceDirectoryTable
     public let allEntries: [ResourceDataEntry]
 
-    init(data: Data, sectionTable: SectionTable, imageBase: UInt32) throws {
+    init(handle: FileHandle, sectionTable: SectionTable, imageBase: UInt32) throws {
         guard let resourceSection = sectionTable.sections.first(where: { $0.name.starts(with: ".rsrc") }) else {
             throw ResourceError.noResourceSection
         }
         var entries: [ResourceDataEntry] = []
-        self.rootDirectoryTable = ResourceDirectoryTable(data: data,
+        self.rootDirectoryTable = ResourceDirectoryTable(handle: handle,
                                                          address: Int(resourceSection.pointerToRawData),
                                                          offset: Int(resourceSection.pointerToRawData),
                                                          sectionTable: sectionTable,
diff --git a/WhiskyKit/PE/ShellLink.swift b/WhiskyKit/PE/ShellLink.swift
index e9b76da00..5ec6092bc 100644
--- a/WhiskyKit/PE/ShellLink.swift
+++ b/WhiskyKit/PE/ShellLink.swift
@@ -20,22 +20,22 @@ import Foundation
 import AppKit
 
 public struct ShellLinkHeader {
-    public static func getProgram(url: URL, data: Data, bottle: Bottle) -> Program? {
+    public static func getProgram(url: URL, handle: FileHandle, bottle: Bottle) -> Program? {
         var offset: Int = 0
-        let headerSize = data.extract(UInt32.self) ?? 0
+        let headerSize = handle.extract(UInt32.self) ?? 0
         // Move past headerSize and linkCLSID
         offset += 4 + 16
-        let rawLinkFlags = data.extract(UInt32.self, offset: offset) ?? 0
+        let rawLinkFlags = handle.extract(UInt32.self, offset: offset) ?? 0
         let linkFlags = LinkFlags(rawValue: rawLinkFlags)
 
         offset = Int(headerSize)
         if linkFlags.contains(.hasLinkTargetIDList) {
             // We don't need this section so just get the size, and skip ahead
-            offset += Int(data.extract(UInt16.self, offset: offset) ?? 0) + 2
+            offset += Int(handle.extract(UInt16.self, offset: offset) ?? 0) + 2
         }
 
         if linkFlags.contains(.hasLinkInfo) {
-            let linkInfo = LinkInfo(data: data,
+            let linkInfo = LinkInfo(handle: handle,
                                     bottle: bottle,
                                     offset: &offset)
             return linkInfo.program
@@ -61,34 +61,34 @@ public struct LinkInfo: Hashable {
     public var linkInfoFlags: LinkInfoFlags
     public var program: Program?
 
-    public init(data: Data, bottle: Bottle, offset: inout Int) {
+    public init(handle: FileHandle, bottle: Bottle, offset: inout Int) {
         let startOfSection = offset
 
-        let linkInfoSize = data.extract(UInt32.self, offset: offset) ?? 0
+        let linkInfoSize = handle.extract(UInt32.self, offset: offset) ?? 0
 
         offset += 4
-        let linkInfoHeaderSize = data.extract(UInt32.self, offset: offset) ?? 0
+        let linkInfoHeaderSize = handle.extract(UInt32.self, offset: offset) ?? 0
 
         offset += 4
-        let rawLinkInfoFlags = data.extract(UInt32.self, offset: offset) ?? 0
+        let rawLinkInfoFlags = handle.extract(UInt32.self, offset: offset) ?? 0
         linkInfoFlags = LinkInfoFlags(rawValue: rawLinkInfoFlags)
 
         if linkInfoFlags.contains(.volumeIDAndLocalBasePath) {
             if linkInfoHeaderSize >= 0x00000024 {
                 offset += 20
-                let localBasePathOffsetUnicode = data.extract(UInt32.self, offset: offset) ?? 0
+                let localBasePathOffsetUnicode = handle.extract(UInt32.self, offset: offset) ?? 0
                 let localPathOffset = startOfSection + Int(localBasePathOffsetUnicode)
 
-                program = getProgram(data: data,
+                program = getProgram(handle: handle,
                                      offset: localPathOffset,
                                      bottle: bottle,
                                      unicode: true)
             } else {
                 offset += 8
-                let localBasePathOffset = data.extract(UInt32.self, offset: offset) ?? 0
+                let localBasePathOffset = handle.extract(UInt32.self, offset: offset) ?? 0
                 let localPathOffset = startOfSection + Int(localBasePathOffset)
 
-                program = getProgram(data: data,
+                program = getProgram(handle: handle,
                                      offset: localPathOffset,
                                      bottle: bottle,
                                      unicode: false)
@@ -98,17 +98,23 @@ public struct LinkInfo: Hashable {
         offset = startOfSection + Int(linkInfoSize)
     }
 
-    func getProgram(data: Data, offset: Int, bottle: Bottle, unicode: Bool) -> Program? {
-        let pathData = data[offset...]
-        if let nullRange = pathData.firstIndex(of: 0) {
-            let encoding: String.Encoding = unicode ? .utf16 : .windowsCP1254
-            if var string = String(data: pathData[..<nullRange], encoding: encoding) {
-                // UNIX-ify the path
-                string.replace("\\", with: "/")
-                string.replace("C:", with: "\(bottle.url.path)/drive_c")
-                let url = URL(filePath: string)
-                return Program(name: url.lastPathComponent, url: url, bottle: bottle)
+    func getProgram(handle: FileHandle, offset: Int, bottle: Bottle, unicode: Bool) -> Program? {
+        do {
+            try handle.seek(toOffset: UInt64(offset))
+            if let pathData = try handle.readToEnd() {
+                if let nullRange = pathData.firstIndex(of: 0) {
+                    let encoding: String.Encoding = unicode ? .utf16 : .windowsCP1254
+                    if var string = String(data: pathData[..<nullRange], encoding: encoding) {
+                        // UNIX-ify the path
+                        string.replace("\\", with: "/")
+                        string.replace("C:", with: "\(bottle.url.path)/drive_c")
+                        let url = URL(filePath: string)
+                        return Program(name: url.lastPathComponent, url: url, bottle: bottle)
+                    }
+                }
             }
+        } catch {
+            return nil
         }
 
         return nil
diff --git a/WhiskyKit/Whisky/Program.swift b/WhiskyKit/Whisky/Program.swift
index 23e5f2249..a312a1a69 100644
--- a/WhiskyKit/Whisky/Program.swift
+++ b/WhiskyKit/Whisky/Program.swift
@@ -41,7 +41,7 @@ public class Program: Hashable {
         self.settings = ProgramSettings(bottleUrl: bottle.url, name: name)
         self.pinned = bottle.settings.pins.contains(where: { $0.url == url })
         do {
-            self.peFile = try PEFile(data: Data(contentsOf: url))
+            self.peFile = try PEFile(handle: FileHandle(forReadingFrom: url))
         } catch {
             self.peFile = nil
         }
diff --git a/WhiskyThumbnail/ThumbnailProvider.swift b/WhiskyThumbnail/ThumbnailProvider.swift
index b0a04bb22..8a9cd233e 100644
--- a/WhiskyThumbnail/ThumbnailProvider.swift
+++ b/WhiskyThumbnail/ThumbnailProvider.swift
@@ -46,7 +46,7 @@ class ThumbnailProvider: QLThumbnailProvider {
         do {
             var image: NSImage?
 
-            let peFile = try PEFile(data: Data(contentsOf: request.fileURL))
+            let peFile = try PEFile(handle: try FileHandle(forReadingFrom: request.fileURL))
             image = peFile.bestIcon()
 
             let reply: QLThumbnailReply = QLThumbnailReply.init(contextSize: thumbnailSize) { () -> Bool in