symtool-backend 0.3.0

symtool-backend provides the symbol manipulation framework for the symtool utility
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

//! Describe patches to an object.

use crate::error::{Error, Result};
use goblin::container::Ctx;
use scroll::ctx::{SizeWith, TryIntoCtx};

/// The location of a set of bytes in an object.
#[derive(Debug)]
pub(crate) struct Location {
    /// The byte offset into the object
    pub offset: usize,

    /// The number of bytes
    pub size: usize,

    /// Contextual information containing endianness and object type
    pub ctx: Ctx,
}

/// A value rooted to a location in an object.
#[derive(Debug)]
pub struct Rooted<T> {
    pub value: T,
    location: Location,
}

impl<T> Rooted<T> {
    pub(crate) fn new(location: Location, value: T) -> Self {
        Self { value, location }
    }

    /// Construct a patch that replaces this rooted value.
    pub fn patch_with<U>(&self, value: U) -> Result<Patch>
    where
        U: TryIntoCtx<Ctx, [u8], Error = goblin::error::Error> + SizeWith<Ctx>,
    {
        Patch::from_ctx(&self.location, value)
    }

    /// Construct a patch that replaces this rooted value with specific bytes.
    pub fn patch_with_bytes(&self, value: &[u8]) -> Result<Patch> {
        Patch::from_bytes(&self.location, value)
    }
}

impl<T> std::ops::Deref for Rooted<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.value
    }
}

/// Represents a patch to an object.
#[derive(Debug)]
pub struct Patch {
    offset: usize,
    data: Vec<u8>,
}

impl Patch {
    fn from_ctx<T>(location: &Location, data: T) -> Result<Self>
    where
        T: TryIntoCtx<Ctx, [u8], Error = goblin::error::Error> + SizeWith<Ctx>,
    {
        let size = T::size_with(&location.ctx);
        if size > location.size {
            return Err(Error::PatchTooBig);
        }
        let mut buf = vec![0u8; size];
        data.try_into_ctx(&mut buf, location.ctx)?;
        Ok(Self {
            offset: location.offset,
            data: buf,
        })
    }

    fn from_bytes(location: &Location, data: &[u8]) -> Result<Self> {
        if data.len() > location.size {
            return Err(Error::PatchTooBig);
        }
        Ok(Self {
            offset: location.offset,
            data: data.to_vec(),
        })
    }

    /// Apply the patch to the bytes of an object.
    pub fn apply(&self, data: &mut [u8]) {
        data[self.offset..(self.offset + self.data.len())].clone_from_slice(&self.data);
    }
}