read_header/
read_header.rs

1use luks::LuksHeader;
2use std::env;
3use std::fs::File;
4use std::process;
5
6fn main() {
7    let args: Vec<String> = env::args().collect();
8    if args.len() < 2 {
9        eprintln!("Usage: {} <device>", args[0]);
10        process::exit(1);
11    }
12
13    let device_path = &args[1];
14    let file = File::open(device_path).unwrap_or_else(|e| {
15        eprintln!("Error opening {}: {}", device_path, e);
16        process::exit(1);
17    });
18
19    match LuksHeader::from_reader(file) {
20        Ok(LuksHeader::V1) => println!("LUKS1 detected on {}", device_path),
21        Ok(LuksHeader::V2(h)) => {
22            println!("LUKS2 detected on {}", device_path);
23            println!("  Label:         {}", h.label);
24            println!("  UUID:          {}", h.uuid);
25            println!("  Subsystem:     {}", h.subsystem);
26            println!("  Checksum Alg:  {}", h.checksum_alg);
27            println!("  Header Size:   {}", h.hdr_size);
28            println!("  Keyslots:      {}", h.num_keyslots());
29            for (id, slot) in &h.metadata.keyslots {
30                match slot {
31                    luks::Luks2Keyslot::Luks2 {
32                        priority, area, kdf, ..
33                    } => {
34                        println!("    Keyslot {}:", id);
35                        println!("      Type:         luks2");
36                        if let Some(p) = priority {
37                            println!("      Priority:     {:?}", p);
38                        }
39                        print_area(area);
40                        print_kdf(kdf);
41                    }
42                    luks::Luks2Keyslot::Reencrypt {
43                        mode,
44                        priority,
45                        area,
46                        kdf,
47                        ..
48                    } => {
49                        println!("    Keyslot {}:", id);
50                        println!("      Type:         reencrypt");
51                        println!("      Mode:         {:?}", mode);
52                        if let Some(p) = priority {
53                            println!("      Priority:     {:?}", p);
54                        }
55                        print_area(area);
56                        print_kdf(kdf);
57                    }
58                }
59            }
60        }
61        Err(e) => {
62            eprintln!("Error reading LUKS header: {}", e);
63            process::exit(1);
64        }
65    }
66}
67
68fn print_area(area: &luks::Luks2Area) {
69    println!("      Area:");
70    match area {
71        luks::Luks2Area::Raw {
72            encryption,
73            key_size,
74            offset,
75            size,
76        } => {
77            println!("        Type:       raw");
78            println!("        Encryption: {}", encryption);
79            println!("        Key Size:   {}", key_size);
80            println!("        Offset:     {}", offset.0);
81            println!("        Size:       {}", size.0);
82        }
83        luks::Luks2Area::None { offset, size } => {
84            println!("        Type:       none");
85            println!("        Offset:     {}", offset.0);
86            println!("        Size:       {}", size.0);
87        }
88        luks::Luks2Area::Journal { offset, size } => {
89            println!("        Type:       journal");
90            println!("        Offset:     {}", offset.0);
91            println!("        Size:       {}", size.0);
92        }
93        luks::Luks2Area::Checksum {
94            offset,
95            size,
96            hash,
97            sector_size,
98        } => {
99            println!("        Type:       checksum");
100            println!("        Hash:       {}", hash);
101            println!("        Sector Size:{}", sector_size);
102            println!("        Offset:     {}", offset.0);
103            println!("        Size:       {}", size.0);
104        }
105        luks::Luks2Area::Datashift {
106            offset,
107            size,
108            shift_size,
109        } => {
110            println!("        Type:       datashift");
111            println!("        Shift Size: {}", shift_size.0);
112            println!("        Offset:     {}", offset.0);
113            println!("        Size:       {}", size.0);
114        }
115        luks::Luks2Area::DatashiftJournal {
116            offset,
117            size,
118            shift_size,
119        } => {
120            println!("        Type:       datashift-journal");
121            println!("        Shift Size: {}", shift_size.0);
122            println!("        Offset:     {}", offset.0);
123            println!("        Size:       {}", size.0);
124        }
125        luks::Luks2Area::DatashiftChecksum {
126            offset,
127            size,
128            hash,
129            sector_size,
130            shift_size,
131        } => {
132            println!("        Type:       datashift-checksum");
133            println!("        Hash:       {}", hash);
134            println!("        Sector Size:{}", sector_size);
135            println!("        Shift Size: {}", shift_size.0);
136            println!("        Offset:     {}", offset.0);
137            println!("        Size:       {}", size.0);
138        }
139    }
140}
141
142fn print_kdf(kdf: &luks::Luks2Kdf) {
143    println!("      KDF:");
144    match kdf {
145        luks::Luks2Kdf::Argon2i {
146            time,
147            memory,
148            cpus,
149            salt,
150        } => {
151            println!("        Type:       argon2i");
152            println!("        Time:       {}", time);
153            println!("        Memory:     {}", memory);
154            println!("        CPUs:       {}", cpus);
155            println!("        Salt:       {}", salt);
156        }
157        luks::Luks2Kdf::Argon2id {
158            time,
159            memory,
160            cpus,
161            salt,
162        } => {
163            println!("        Type:       argon2id");
164            println!("        Time:       {}", time);
165            println!("        Memory:     {}", memory);
166            println!("        CPUs:       {}", cpus);
167            println!("        Salt:       {}", salt);
168        }
169        luks::Luks2Kdf::Pbkdf2 {
170            hash,
171            iterations,
172            salt,
173        } => {
174            println!("        Type:       pbkdf2");
175            println!("        Hash:       {}", hash);
176            println!("        Iterations: {}", iterations);
177            println!("        Salt:       {}", salt);
178        }
179    }
180}
read_header/read_header.rs

read_header/
read_header.rs
