cryptsetup-rs 0.3.2

Rust wrapper around the libcryptsetup library, allowing manipulation of LUKS devices in Linux
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

#![deny(warnings)]
#[warn(unused_must_use)]
extern crate cryptsetup_rs;
extern crate env_logger;

use cryptsetup_rs::*;
use std::env;

fn dump_slot(crypt_device: &dyn Luks1CryptDevice, slot: Keyslot) -> Result<()> {
    let status = match crypt_device.keyslot_status(slot) {
        crypt_keyslot_info::CRYPT_SLOT_INVALID => "INVALID",
        crypt_keyslot_info::CRYPT_SLOT_INACTIVE => "DISABLED",
        crypt_keyslot_info::CRYPT_SLOT_ACTIVE | crypt_keyslot_info::CRYPT_SLOT_ACTIVE_LAST => "ENABLED",
        crypt_keyslot_info::CRYPT_SLOT_UNBOUND => "UNBOUND",
    };

    println!("Key Slot {}: {}", slot, status);
    match status {
        "ENABLED" => (), // TODO  add keyslot information
        _ => (),
    }
    Ok(())
}

fn dump(device_path: &str) -> Result<()> {
    let dev = open(device_path)?.luks1()?;

    println!("LUKS header information for {}", dev.device_name());
    println!();
    println!("{:<16}{}", "Version:", "1");
    println!("{:<16}{}", "Cipher name:", dev.cipher());
    println!("{:<16}{}", "Cipher mode:", dev.cipher_mode());
    println!("{:<16}{}", "Hash spec:", dev.hash_spec());
    println!("{:<16}{}", "Payload offset:", dev.payload_offset());
    println!("{:<16}{}", "MK bits:", dev.mk_bits());

    print!("{:<16}", "MK digest:");
    for b in dev.mk_digest().iter() {
        print!("{:x} ", b);
    }
    println!();

    let salt = dev.mk_salt();
    print!("{:<16}", "MK salt:");
    for b in salt[0..16].iter() {
        print!("{:x} ", b);
    }
    println!();
    print!("{:<16}", "");
    for b in salt[16..32].iter() {
        print!("{:x} ", b);
    }
    println!();

    println!("{:<16}{}", "MK iterations:", dev.mk_iterations());
    println!("{:<16}{}", "UUID:", dev.uuid());

    println!();

    for slot in 0..8 {
        dump_slot(&dev, slot)?;
    }

    Ok(())
}

fn main() {
    let args: Vec<String> = env::args().skip(1).collect();
    if args.len() != 1 {
        println!("Usage: luks_dump <device path>");
        ::std::process::exit(1);
    }
    let device_path = args[0].as_str();

    if let Err(e) = dump(device_path) {
        println!("Error: {:?}", e);
        ::std::process::exit(2);
    }
}