monster-rs 0.4.1

Monster is a symbolic execution engine for 64-bit RISC-U code
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use super::system::instruction_to_str;
use riscu::Instruction;
use std::fmt;

pub trait BugInfo: fmt::Display + fmt::Debug + Clone {
    type Value: fmt::Display + fmt::Debug + Clone;
}

#[derive(Debug, Clone)]
pub enum Bug<Info: BugInfo> {
    DivisionByZero {
        info: Info,
    },

    AccessToUnitializedMemory {
        info: Info,
        reason: UninitializedMemoryAccessReason<Info>,
    },

    AccessToUnalignedAddress {
        info: Info,
        address: u64,
    },

    AccessToOutOfRangeAddress {
        info: Info,
    },

    ExitCodeGreaterZero {
        info: Info,
        exit_code: Info::Value,
        address: u64,
    },
}

impl<Info> fmt::Display for Bug<Info>
where
    Info: BugInfo,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Bug::DivisionByZero { info } => write!(f, "reason: division by zero\n{}", info),
            Bug::AccessToUnitializedMemory { info, reason } => write!(
                f,
                "reason: access to uninitialized memory\n{}\n{}",
                info, reason,
            ),
            Bug::AccessToUnalignedAddress { info, address } => write!(
                f,
                "reason: access to unaligned memory address {:#x}\n{}",
                address, info
            ),
            Bug::AccessToOutOfRangeAddress { info } => write!(
                f,
                "reason: accessed a memory address out of virtual address space\n{}",
                info,
            ),
            Bug::ExitCodeGreaterZero {
                info,
                exit_code,
                address,
            } => write!(
                f,
                "reason: exit code ({}) greater than zero at pc={:#x}\n{}",
                exit_code, address, info
            ),
        }
    }
}

#[derive(Debug, Clone)]
pub enum UninitializedMemoryAccessReason<Info: BugInfo> {
    ReadUnintializedMemoryAddress {
        description: String,
        address: u64,
    },
    InstructionWithUninitializedOperand {
        instruction: Instruction,
        operands: Vec<Info::Value>,
    },
}

impl<Info> fmt::Display for UninitializedMemoryAccessReason<Info>
where
    Info: BugInfo,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            UninitializedMemoryAccessReason::InstructionWithUninitializedOperand {
                instruction,
                operands,
            } => write!(
                f,
                "instruction: {}  operands: {:?}",
                instruction_to_str(*instruction),
                operands
            ),
            UninitializedMemoryAccessReason::ReadUnintializedMemoryAddress {
                description,
                address,
            } => write!(f, "{} (pc: {:#x})", description, address),
        }
    }
}