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,
33 af,
34 area,
35 kdf,
36 ..
37 } => {
38 println!(" Keyslot {}:", id);
39 println!(" Type: luks2");
40 if let Some(p) = priority {
41 println!(" Priority: {:?}", p);
42 }
43 print_af(af);
44 print_area(area);
45 print_kdf(kdf);
46 }
47 luks::Luks2Keyslot::Reencrypt {
48 mode,
49 priority,
50 af,
51 area,
52 kdf,
53 ..
54 } => {
55 println!(" Keyslot {}:", id);
56 println!(" Type: reencrypt");
57 println!(" Mode: {:?}", mode);
58 if let Some(p) = priority {
59 println!(" Priority: {:?}", p);
60 }
61 print_af(af);
62 print_area(area);
63 print_kdf(kdf);
64 }
65 }
66 }
67 }
68 Err(e) => {
69 eprintln!("Error reading LUKS header: {}", e);
70 process::exit(1);
71 }
72 }
73}
74
75fn print_af(af: &luks::Luks2Af) {
76 println!(" AF:");
77 println!(" Type: {}", af.af_type);
78 println!(" Stripes: {}", af.stripes);
79 println!(" Hash: {}", af.hash);
80}
81
82fn print_area(area: &luks::Luks2Area) {
83 println!(" Area:");
84 match area {
85 luks::Luks2Area::Raw {
86 encryption,
87 key_size,
88 offset,
89 size,
90 } => {
91 println!(" Type: raw");
92 println!(" Encryption: {}", encryption);
93 println!(" Key Size: {}", key_size);
94 println!(" Offset: {}", offset.0);
95 println!(" Size: {}", size.0);
96 }
97 luks::Luks2Area::None { offset, size } => {
98 println!(" Type: none");
99 println!(" Offset: {}", offset.0);
100 println!(" Size: {}", size.0);
101 }
102 luks::Luks2Area::Journal { offset, size } => {
103 println!(" Type: journal");
104 println!(" Offset: {}", offset.0);
105 println!(" Size: {}", size.0);
106 }
107 luks::Luks2Area::Checksum {
108 offset,
109 size,
110 hash,
111 sector_size,
112 } => {
113 println!(" Type: checksum");
114 println!(" Hash: {}", hash);
115 println!(" Sector Size:{}", sector_size);
116 println!(" Offset: {}", offset.0);
117 println!(" Size: {}", size.0);
118 }
119 luks::Luks2Area::Datashift {
120 offset,
121 size,
122 shift_size,
123 } => {
124 println!(" Type: datashift");
125 println!(" Shift Size: {}", shift_size.0);
126 println!(" Offset: {}", offset.0);
127 println!(" Size: {}", size.0);
128 }
129 luks::Luks2Area::DatashiftJournal {
130 offset,
131 size,
132 shift_size,
133 } => {
134 println!(" Type: datashift-journal");
135 println!(" Shift Size: {}", shift_size.0);
136 println!(" Offset: {}", offset.0);
137 println!(" Size: {}", size.0);
138 }
139 luks::Luks2Area::DatashiftChecksum {
140 offset,
141 size,
142 hash,
143 sector_size,
144 shift_size,
145 } => {
146 println!(" Type: datashift-checksum");
147 println!(" Hash: {}", hash);
148 println!(" Sector Size:{}", sector_size);
149 println!(" Shift Size: {}", shift_size.0);
150 println!(" Offset: {}", offset.0);
151 println!(" Size: {}", size.0);
152 }
153 }
154}
155
156fn print_kdf(kdf: &luks::Luks2Kdf) {
157 println!(" KDF:");
158 match kdf {
159 luks::Luks2Kdf::Argon2i {
160 time,
161 memory,
162 cpus,
163 salt,
164 } => {
165 println!(" Type: argon2i");
166 println!(" Time: {}", time);
167 println!(" Memory: {}", memory);
168 println!(" CPUs: {}", cpus);
169 println!(" Salt: {}", salt);
170 }
171 luks::Luks2Kdf::Argon2id {
172 time,
173 memory,
174 cpus,
175 salt,
176 } => {
177 println!(" Type: argon2id");
178 println!(" Time: {}", time);
179 println!(" Memory: {}", memory);
180 println!(" CPUs: {}", cpus);
181 println!(" Salt: {}", salt);
182 }
183 luks::Luks2Kdf::Pbkdf2 {
184 hash,
185 iterations,
186 salt,
187 } => {
188 println!(" Type: pbkdf2");
189 println!(" Hash: {}", hash);
190 println!(" Iterations: {}", iterations);
191 println!(" Salt: {}", salt);
192 }
193 }
194}