keylight 0.3.0

Keylight licensing SDK — activate/validate licenses with offline Ed25519 lease verification.
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

/// Stable per-device identifier (parity with Swift SystemDeviceIdentity).
pub trait DeviceIdentity: Send + Sync {
    fn stable_id(&self) -> String;
}

pub struct SystemDeviceIdentity;
impl DeviceIdentity for SystemDeviceIdentity {
    fn stable_id(&self) -> String {
        read_machine_id().unwrap_or_else(persisted_fallback_id)
    }
}

/// Caller-provided fixed id (parity with Swift FixedDeviceIdentity), for tests/CI.
pub struct FixedDeviceIdentity(pub String);
impl DeviceIdentity for FixedDeviceIdentity {
    fn stable_id(&self) -> String {
        self.0.clone()
    }
}

#[cfg(target_os = "linux")]
fn read_machine_id() -> Option<String> {
    std::fs::read_to_string("/etc/machine-id")
        .ok()
        .or_else(|| std::fs::read_to_string("/var/lib/dbus/machine-id").ok())
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty())
}
#[cfg(target_os = "macos")]
fn read_machine_id() -> Option<String> {
    let out = std::process::Command::new("ioreg")
        .args(["-rd1", "-c", "IOPlatformExpertDevice"])
        .output()
        .ok()?;
    let text = String::from_utf8_lossy(&out.stdout);
    text.lines()
        .find(|l| l.contains("IOPlatformUUID"))
        .and_then(|l| l.split('"').nth(3))
        .map(|s| s.to_string())
}
#[cfg(target_os = "windows")]
fn read_machine_id() -> Option<String> {
    let out = std::process::Command::new("reg")
        .args([
            "query",
            r"HKLM\SOFTWARE\Microsoft\Cryptography",
            "/v",
            "MachineGuid",
        ])
        .output()
        .ok()?;
    let text = String::from_utf8_lossy(&out.stdout);
    text.split_whitespace()
        .last()
        .map(|s| s.to_string())
        .filter(|s| !s.is_empty())
}
#[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
fn read_machine_id() -> Option<String> {
    None
}

/// Last resort: a random UUID persisted in the config dir, so the id is stable per install.
fn persisted_fallback_id() -> String {
    use std::io::Write;
    let dir = directories::ProjectDirs::from("dev", "keylight", "keylight")
        .map(|p| p.config_dir().to_path_buf())
        .unwrap_or_else(std::env::temp_dir);
    let _ = std::fs::create_dir_all(&dir);
    let path = dir.join("device-id");
    if let Ok(existing) = std::fs::read_to_string(&path) {
        let t = existing.trim();
        if !t.is_empty() {
            return t.to_string();
        }
    }
    let id = uuid_v4();
    if let Ok(mut f) = std::fs::File::create(&path) {
        let _ = f.write_all(id.as_bytes());
    }
    id
}

/// Public wrapper around the internal UUIDv4 generator (used by the client for free-tier ids).
pub fn uuid_v4_pub() -> String {
    uuid_v4()
}

/// Tiny UUIDv4 from `rand` (avoids a uuid dependency).
fn uuid_v4() -> String {
    use rand::Rng;
    let b: [u8; 16] = rand::thread_rng().r#gen();
    let mut b = b;
    b[6] = (b[6] & 0x0f) | 0x40;
    b[8] = (b[8] & 0x3f) | 0x80;
    format!(
        "{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
        b[0],
        b[1],
        b[2],
        b[3],
        b[4],
        b[5],
        b[6],
        b[7],
        b[8],
        b[9],
        b[10],
        b[11],
        b[12],
        b[13],
        b[14],
        b[15]
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn fixed_identity_returns_value() {
        assert_eq!(FixedDeviceIdentity("abc".into()).stable_id(), "abc");
    }
    #[test]
    fn system_identity_is_nonempty_and_stable() {
        let a = SystemDeviceIdentity.stable_id();
        assert!(!a.is_empty());
        assert_eq!(a, SystemDeviceIdentity.stable_id());
    }
    #[test]
    fn uuid_v4_has_version_nibble() {
        assert_eq!(uuid_v4().chars().nth(14).unwrap(), '4');
    }
}