refactor: consolidate platform engines into senbei-engine

senbei-engine/src/windows/error.rs

@@ -0,0 +1,253 @@
+pub use senbei_crypto::{BufferOperation, DecompressionFailure};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DecompressionStage {
+    ExeStage3,
+    ExeStage3Secondary,
+    ExeStage4,
+    ExeStage5,
+    Pe32FourthStage,
+    Pe32FifthStage,
+    Pe32SeventhStage,
+    DllCodeBlock1,
+    DllCodeBlock2,
+    DllCodeBlock3,
+    DllCodeBlock4,
+}
+
+impl std::fmt::Display for DecompressionStage {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Self::ExeStage3 => "EXE stage3",
+            Self::ExeStage3Secondary => "EXE secondary stage3",
+            Self::ExeStage4 => "EXE stage4",
+            Self::ExeStage5 => "EXE stage5",
+            Self::Pe32FourthStage => "PE32 fourth stage",
+            Self::Pe32FifthStage => "PE32 fifth stage",
+            Self::Pe32SeventhStage => "PE32 seventh stage",
+            Self::DllCodeBlock1 => "DLL code block 1",
+            Self::DllCodeBlock2 => "DLL code block 2",
+            Self::DllCodeBlock3 => "DLL code block 3",
+            Self::DllCodeBlock4 => "DLL code block 4",
+        })
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BytecodeStage {
+    ExeStage4,
+    ExeStage5,
+    Pe32CustomDecryptor,
+    Pe32FileDecryptor,
+    DllPrimaryDecryptor,
+    DllSectionDecryptor,
+}
+
+impl std::fmt::Display for BytecodeStage {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Self::ExeStage4 => "EXE stage4",
+            Self::ExeStage5 => "EXE stage5",
+            Self::Pe32CustomDecryptor => "PE32 custom decryptor",
+            Self::Pe32FileDecryptor => "PE32 file decryptor",
+            Self::DllPrimaryDecryptor => "DLL primary decryptor",
+            Self::DllSectionDecryptor => "DLL section decryptor",
+        })
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SectionPipeline {
+    ExePe32Plus,
+    ExePe32,
+    Dll,
+}
+
+impl std::fmt::Display for SectionPipeline {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Self::ExePe32Plus => "PE32+ EXE",
+            Self::ExePe32 => "PE32 EXE",
+            Self::Dll => "DLL",
+        })
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DescriptorTable {
+    DllSectionBlocks,
+    DllZeroFill,
+}
+
+impl std::fmt::Display for DescriptorTable {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Self::DllSectionBlocks => "DLL section-block",
+            Self::DllZeroFill => "DLL zero-fill",
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+#[non_exhaustive]
+pub enum UnpackError {
+    #[error("input too short (need at least {required} bytes, got {actual})")]
+    InputTooShort { actual: usize, required: usize },
+
+    #[error("decrypted header magic mismatch (got 0x{found:08X})")]
+    HeaderMagicMismatch { found: u32 },
+
+    #[error("anchor field not found — corrupt data or wrong offset")]
+    AnchorNotFound,
+
+    #[error("stage1 descriptor not found near anchor 0x{anchor:08X}")]
+    Stage1DescriptorNotFound { anchor: u32 },
+
+    #[error("stage2 field not found — corrupt data or wrong offset")]
+    Stage2NotFound,
+
+    #[error("chk_src_start not found — corrupt data or wrong offset")]
+    ChkSrcStartNotFound,
+
+    #[error("table_start not found — corrupt data or wrong offset")]
+    TableStartNotFound,
+
+    #[error("{0} bytecode generation failed — corrupt data or wrong offset")]
+    BytecodeGenerationFailed(BytecodeStage),
+
+    #[error("stage5 marker not found — this build's layout is not supported by this unpacker")]
+    Stage5MarkerNotFound,
+
+    #[error("not a Crackproof-protected file")]
+    NotCrackproof,
+
+    #[error("invalid PE header offset {offset} for {input_len}-byte input")]
+    InvalidPeOffset { offset: i64, input_len: usize },
+
+    #[error("DLL pipeline requires PE32+ optional-header magic, got 0x{found:04X}")]
+    UnsupportedDllPeMagic { found: u16 },
+
+    #[error(
+        "DLL primary descriptor address 0x{address:08X} is below layout base 0x{minimum:08X} or outside {image_len}-byte image"
+    )]
+    InvalidDllPrimaryDescriptor {
+        address: u32,
+        minimum: u32,
+        image_len: usize,
+    },
+
+    #[error("invalid SizeOfImage {size}; expected 1..={max}")]
+    InvalidImageSize { size: i64, max: u64 },
+
+    #[error(
+        "{operation} range out of bounds (offset {offset}, size {size}, buffer length {buffer_len})"
+    )]
+    BufferRangeOutOfBounds {
+        operation: BufferOperation,
+        offset: usize,
+        size: usize,
+        buffer_len: usize,
+    },
+
+    #[error(
+        "EXE checksum descriptor at 0x{descriptor:08X} points outside input (offset {offset}, size {size}, input length {image_len})"
+    )]
+    ExeChecksumRangeOutOfBounds {
+        descriptor: u32,
+        offset: usize,
+        size: usize,
+        image_len: usize,
+    },
+
+    #[error(
+        "{table} descriptor out of bounds (offset {offset}, size 16, image length {image_len})"
+    )]
+    DescriptorOutOfBounds {
+        table: DescriptorTable,
+        offset: usize,
+        image_len: usize,
+    },
+
+    #[error("PE32 tbl not found — corrupt data or wrong offset")]
+    Pe32TblNotFound,
+
+    #[error("PE32 thirdStage decrypt failed — corrupt data or wrong offset")]
+    Pe32ThirdStageFailed,
+
+    #[error("PE32 customDecryptor not found in sevenStage")]
+    Pe32CustomDecryptorNotFound,
+
+    #[error("PE32 eighthStageKey not found")]
+    Pe32EighthKeyNotFound,
+
+    #[error("PE32 file LFSR not found in eighthStage")]
+    Pe32FileLfsrNotFound,
+
+    #[error("{stage} decompression failed: {reason}")]
+    StageDecompressionFailed {
+        stage: DecompressionStage,
+        reason: DecompressionFailure,
+    },
+
+    #[error("{pipeline} section block {block} decompression failed")]
+    SectionDecompressionFailed {
+        pipeline: SectionPipeline,
+        block: usize,
+    },
+
+    #[error("AES key schedule is outside the image at offset {offset}")]
+    InvalidAesKeySchedule { offset: u32 },
+
+    #[error("Huffman table is outside the image at offset {offset}")]
+    InvalidHuffmanTable { offset: u32 },
+
+    #[error("DLL pipeline failed: {dll}; EXE fallback failed: {exe}")]
+    PipelineFallbackFailed {
+        dll: Box<UnpackError>,
+        exe: Box<UnpackError>,
+    },
+
+    #[error(
+        "PE32 second-stage range is invalid (offset {offset}, size {size}, image length {image_len})"
+    )]
+    Pe32SecondStageRangeInvalid {
+        offset: u32,
+        size: u32,
+        image_len: usize,
+    },
+
+    #[error("PE32 relocation-data descriptor not found")]
+    Pe32RelocationDataNotFound,
+
+    #[error("file decryptor candidate failed structural validation")]
+    FileDecryptorValidationFailed,
+
+    #[error("PE32 memory image could not be rebuilt as a file-layout PE")]
+    Pe32OutputLayoutInvalid,
+
+    #[error("internal panic at {file}:{line}:{column}: {message}")]
+    InternalPanic {
+        message: String,
+        file: String,
+        line: u32,
+        column: u32,
+    },
+}
+
+impl From<senbei_crypto::Error> for UnpackError {
+    fn from(error: senbei_crypto::Error) -> Self {
+        match error {
+            senbei_crypto::Error::BufferRangeOutOfBounds {
+                operation,
+                offset,
+                size,
+                buffer_len,
+            } => Self::BufferRangeOutOfBounds {
+                operation,
+                offset,
+                size,
+                buffer_len,
+            },
+        }
+    }
+}