ds-rom 0.7.0

Library for extracting/building Nintendo DS ROMs.
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

use std::{borrow::Cow, fmt::Display};

use super::{HmacSha1Signature, Overlay};
use crate::crypto::hmac_sha1::HmacSha1;

/// An overlay table, used for both ARM9 and ARM7 overlays. This is the raw struct, see the plain one [here](crate::rom::OverlayTable).
pub struct OverlayTable<'a> {
    overlays: Cow<'a, [Overlay]>,
    signature: Option<HmacSha1Signature>,
}

impl<'a> OverlayTable<'a> {
    /// Creates a new overlay table.
    pub fn new<O>(overlays: O, signature: Option<HmacSha1Signature>) -> Self
    where
        O: Into<Cow<'a, [Overlay]>>,
    {
        Self { overlays: overlays.into(), signature }
    }

    /// Returns the overlays in the table.
    pub fn overlays(&'a self) -> &'a [Overlay] {
        self.overlays.as_ref()
    }

    /// Computes the HMAC-SHA1 signature of this overlay table using the given HMAC-SHA1 instance.
    pub fn compute_signature(&self, hmac_sha1: &HmacSha1) -> HmacSha1Signature {
        let bytes = bytemuck::cast_slice(&self.overlays);
        HmacSha1Signature::from_hmac_sha1(hmac_sha1, bytes)
    }

    /// Verifies the HMAC-SHA1 signature of this overlay table using the given HMAC-SHA1 instance.
    pub fn verify_signature(&self, hmac_sha1: &HmacSha1) -> bool {
        let Some(signature) = self.signature() else {
            return true;
        };

        let computed_signature = self.compute_signature(hmac_sha1);
        computed_signature == signature
    }

    /// Returns the HMAC-SHA1 signature of the overlay table, if it exists.
    pub fn signature(&self) -> Option<HmacSha1Signature> {
        self.signature
    }

    /// Returns `true` if this overlay table has an HMAC-SHA1 signature.
    pub fn is_signed(&self) -> bool {
        self.signature.is_some()
    }

    /// Returns the raw bytes of the overlay table.
    pub fn as_bytes(&self) -> &[u8] {
        bytemuck::cast_slice(self.overlays.as_ref())
    }

    /// Returns a [`DisplayOverlayTable`] which implements [`Display`].
    pub fn display(&'a self, indent: usize) -> DisplayOverlayTable<'a> {
        DisplayOverlayTable { overlay_table: self, indent }
    }
}

/// Can be used to display values in [`OverlayTable`].
pub struct DisplayOverlayTable<'a> {
    overlay_table: &'a OverlayTable<'a>,
    indent: usize,
}

impl Display for DisplayOverlayTable<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let i = " ".repeat(self.indent);
        let overlay_table = &self.overlay_table;
        let overlays = overlay_table.overlays();
        let signature = overlay_table.signature().map_or("None".to_string(), |s| s.to_string());

        writeln!(f, "{i}Overlay Table:")?;
        writeln!(f, "{i}Signature: {}", signature)?;
        writeln!(f, "{i}Overlays:")?;

        for overlay in overlays {
            writeln!(f, "{}", overlay.display(self.indent + 2))?;
        }

        Ok(())
    }
}