frida 0.17.2

Rust bindings for Frida
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

/*
 * Copyright © 2022 Jean Marchand
 *
 * Licence: wxWindows Library Licence, Version 3.1
 */

use frida_sys::_FridaDeviceManager;
use std::ffi::CString;
use std::marker::PhantomData;

use crate::device::{self, Device};
use crate::DeviceType;
use crate::Error;
use crate::Frida;
use crate::Result;

/// Platform-independent device manager abstraction access.
pub struct DeviceManager<'a> {
    manager_ptr: *mut _FridaDeviceManager,
    phantom: PhantomData<&'a _FridaDeviceManager>,
}

impl<'a> DeviceManager<'a> {
    /// Obtain an DeviceManager handle, ensuring that the runtime is properly initialized. This may be called as many
    /// times as needed, and results in a no-op if the DeviceManager is already initialized.
    pub fn obtain<'b>(_frida: &'b Frida) -> Self
    where
        'b: 'a,
    {
        DeviceManager {
            manager_ptr: unsafe { frida_sys::frida_device_manager_new() },
            phantom: PhantomData,
        }
    }

    /// Returns all devices.
    pub fn enumerate_all_devices<'b>(&'a self) -> Vec<Device<'b>>
    where
        'a: 'b,
    {
        let mut devices = Vec::new();
        let mut error: *mut frida_sys::GError = std::ptr::null_mut();

        let devices_ptr = unsafe {
            frida_sys::frida_device_manager_enumerate_devices_sync(
                self.manager_ptr,
                std::ptr::null_mut(),
                &mut error,
            )
        };

        if error.is_null() {
            let num_devices = unsafe { frida_sys::frida_device_list_size(devices_ptr) };
            devices.reserve(num_devices as usize);

            for i in 0..num_devices {
                let device =
                    Device::from_raw(unsafe { frida_sys::frida_device_list_get(devices_ptr, i) });
                devices.push(device);
            }
        }

        unsafe { frida_sys::frida_unref(devices_ptr as _) }
        devices
    }

    /// Returns the device of the specified type.
    pub fn get_device_by_type(&'a self, r#type: DeviceType) -> Result<Device<'a>> {
        let mut error: *mut frida_sys::GError = std::ptr::null_mut();

        let device_ptr = unsafe {
            frida_sys::frida_device_manager_get_device_by_type_sync(
                self.manager_ptr,
                r#type.into(),
                0,
                std::ptr::null_mut(),
                &mut error,
            )
        };

        if !error.is_null() {
            return Err(Error::DeviceLookupFailed);
        }

        Ok(Device::from_raw(device_ptr))
    }

    /// Returns the remote device with the specified host.
    pub fn get_remote_device(&'a self, host: &str) -> Result<Device<'a>> {
        let mut error: *mut frida_sys::GError = std::ptr::null_mut();
        let host_cstring = CString::new(host).map_err(|_| Error::CStringFailed)?;

        let device_ptr = unsafe {
            frida_sys::frida_device_manager_add_remote_device_sync(
                self.manager_ptr,
                host_cstring.as_ptr(),
                std::ptr::null_mut(),
                std::ptr::null_mut(),
                &mut error,
            )
        };

        if !error.is_null() {
            return Err(Error::DeviceLookupFailed);
        }

        Ok(Device::from_raw(device_ptr))
    }

    /// Returns the local device.
    pub fn get_local_device(&'a self) -> Result<Device<'a>> {
        self.get_device_by_type(device::DeviceType::Local)
    }

    /// Returns the device with the specified id.
    ///
    /// # Example
    /// ```no_run
    /// let frida = unsafe { frida::Frida::obtain() };
    /// let device_manager = frida::DeviceManager::obtain(&frida);
    ///
    /// let id = "<some id>";
    /// let device = device_manager.get_device_by_id(id).unwrap();
    /// assert_eq!(device.get_id(), id);
    /// ```
    pub fn get_device_by_id(&'a self, device_id: &str) -> Result<Device<'a>> {
        let mut error: *mut frida_sys::GError = std::ptr::null_mut();
        let cstring = CString::new(device_id).unwrap();

        let device_ptr = unsafe {
            frida_sys::frida_device_manager_get_device_by_id_sync(
                self.manager_ptr,
                cstring.as_ptr(),
                0,
                std::ptr::null_mut(),
                &mut error,
            )
        };

        if !error.is_null() {
            return Err(Error::DeviceLookupFailed);
        }

        Ok(Device::from_raw(device_ptr))
    }
}

impl Drop for DeviceManager<'_> {
    fn drop(&mut self) {
        unsafe {
            frida_sys::frida_device_manager_close_sync(
                self.manager_ptr,
                std::ptr::null_mut(),
                std::ptr::null_mut(),
            );
            frida_sys::frida_unref(self.manager_ptr as _)
        }
    }
}