foxmark3 0.1.1

Send/receive Proxmark 3 commands
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

//! Commands and structures for [`Proxmark::version`] requests.

use std::{fmt, time::Duration};

use bytemuck::from_bytes;
use tracing::error;

use crate::raw::{Command, request};

use super::{Error, Proxmark};

#[repr(C, packed)]
#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct Header {
    id: u32,
    section_size: u32,
    version_len: u32,
}

const SZ_HEADER: usize = size_of::<Header>();

/// Version information provided by the device firmware.
///
/// [`Proxmark::version`] requests this data.
#[derive(Debug, Clone)]
pub struct Version {
    /// The value of the ID register of the AT91C running the firmware.
    pub id: u32,
    /// The size of the program data section.
    pub section_size: u32,
    /// Arbitrary information about the device firmware. The format of the string is subject to the
    /// device firmware; `foxmark3` has no control over it.
    pub report: String,
}

impl Proxmark {
    /// Requests the device's firmware version information.
    #[tracing::instrument(skip(self), level = tracing::Level::TRACE)]
    pub fn version(&mut self) -> Result<Version, Error> {
        let resp = self
            .0
            .request_response(request::ng(Command::VERSION, []), Duration::from_secs(1))?;

        if resp.payload().len() < SZ_HEADER {
            error!(
                "payload was too short! {} < {SZ_HEADER}",
                resp.payload().len()
            );

            return Err(Error::MalformedResponse(Box::new(resp)));
        }

        let header: &Header = from_bytes(&resp.payload()[..SZ_HEADER]);
        let version_utf8 = &resp.payload()[SZ_HEADER..];

        let version_len = header.version_len as usize;
        if version_len != version_utf8.len() {
            error!(
                "self-described payload length ({version_len}) does not match what is indicated by NG header length ({})!",
                version_utf8.len()
            );

            return Err(Error::MalformedResponse(Box::new(resp)));
        }

        Ok(Version {
            id: header.id,
            section_size: header.section_size,
            report: String::from_utf8_lossy(version_utf8).into_owned(),
        })
    }
}

impl fmt::Display for Version {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let max_length = self.report.lines().map(str::len).max().unwrap_or(0);

        let table_start = "======== PM3 VERSION ========";
        let table_extension = max_length.saturating_sub(table_start.len());

        f.write_str(table_start)?;
        for _ in 0..table_extension {
            f.write_str("=")?;
        }

        write!(
            f,
            concat!(
                "\n",
                " ID: 0x{:08X}\n",
                " Section size: {}\n",
                " Report:\n\n{}\n",
            ),
            self.id, self.section_size, self.report
        )?;

        for _ in 0..(table_start.len() + table_extension) {
            f.write_str("=")?;
        }

        Ok(())
    }
}