psitool 0.3.0

The 100% free and open-source Remote Viewing toolset.
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

use anyhow::anyhow;
use data_encoding::Specification;
use serde::de::{self, Deserialize, Deserializer};
use serde::ser::{Serialize, Serializer};
use std::fmt;
use std::str::FromStr;
use uuid::Uuid;

pub const BYTES_RV: [u8; 16] = *b"RV\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
pub const NAMESPACE_RV: Uuid = Uuid::from_bytes(BYTES_RV);
pub const SPEC_BASE32: &str = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";

// A Remote Viewing UID is like a UUID, but easy to write down, and based on UUIDv5.
#[derive(Clone, Debug, PartialEq)]
pub struct Rvuid {
    pub uuid: Uuid,
    pub rvuid: String,
}

impl Rvuid {
    pub fn from_bytes(data: &[u8]) -> Self {
        let uuid = uuid_from_bytes(data);
        let rvuid = Self::rvuid_from_uuid(uuid);
        Self { uuid, rvuid }
    }
    pub fn rvuid_from_uuid(uuid: Uuid) -> String {
        // Crockford-like Base32 alphabet (no I, L, O, U since they're a big ambiguous")
        let mut spec = Specification::new();
        spec.symbols.push_str(SPEC_BASE32);
        let crockford = spec.encoding().unwrap();
        let encoded = crockford.encode(uuid.as_bytes());
        let part1 = &encoded[..4];
        let part2 = &encoded[4..8];
        let part3 = &encoded[8..];
        format!("R-{}-{}-{}", part1, part2, part3)
    }
}

impl fmt::Display for Rvuid {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.rvuid)
    }
}

impl FromStr for Rvuid {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        if !s.starts_with("R-") {
            anyhow::bail!("invalid RVUID: must start with 'R-' prefix.");
        }

        let raw = s.trim_start_matches("R-").replace('-', "");

        let mut spec = Specification::new();
        spec.symbols.push_str(SPEC_BASE32);
        let decoder = spec.encoding().unwrap();

        let bytes = decoder
            .decode(raw.as_bytes())
            .map_err(|e| anyhow!("base32 decode error: {}", e))?;

        if bytes.len() != 16 {
            return Err(anyhow!("expected 16 bytes for UUID, got {}", bytes.len()));
        }

        let uuid = Uuid::from_slice(&bytes)?;

        Ok(Rvuid {
            uuid,
            rvuid: s.to_string(),
        })
    }
}

impl<'de> Deserialize<'de> for Rvuid {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;

        // parse from string
        Rvuid::from_str(&s).map_err(de::Error::custom)
    }
}

impl Serialize for Rvuid {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(&self.rvuid)
    }
}

fn uuid_from_bytes(data: &[u8]) -> Uuid {
    Uuid::new_v5(&NAMESPACE_RV, data)
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde::Deserialize;

    #[test]
    fn test_uuid_from_bytes() {
        let empty: [u8; 0] = [];
        let empty2: [u8; 0] = [];
        let oneval: [u8; 1] = [99];
        let oneval2: [u8; 1] = [99];
        assert_eq!(
            uuid_from_bytes(&empty),
            Uuid::new_v5(&NAMESPACE_RV, &empty2)
        );
        assert_eq!(
            uuid_from_bytes(&oneval),
            Uuid::new_v5(&NAMESPACE_RV, &oneval2)
        );
    }

    #[derive(Debug, Deserialize)]
    struct Foo {
        id: Rvuid,
    }

    #[test]
    fn test_rvuid_deserialize_from_yaml() {
        let yaml = r#"
id: "R-2DTH-GZW5-W9FMX29F6HJ52Q8N9C"
"#;

        let foo: Foo = serde_yaml::from_str(yaml).expect("failed to deserialize");
        assert_eq!(foo.id.to_string(), "R-2DTH-GZW5-W9FMX29F6HJ52Q8N9C");
    }
}