reduced redundant code

error.rs: typo

.drone.yml

@@ -12,3 +12,23 @@ steps:
    commands:
     - apt update && apt install -y libcryptsetup-dev libkeyutils-dev
     - cargo test
+
+ - name: build
+   image: rust:1.37.0
+   commands:
+    - apt update && apt install -y libcryptsetup-dev libkeyutils-dev
+    - cargo install -f --path . --root .
+   when:
+    event: tag
+ - name: publish
+   image: plugins/github-release
+   settings:
+     api_key:
+      from_secret: github_release
+     files:
+      - bin/fido2luks
+     checksum:
+      - md5
+      - sha256
+   when:
+    event: tag    

Cargo.toml

@@ -1,24 +1,30 @@
 [package]
 name = "fido2luks"
-version = "0.1.0"
+version = "0.2.7"
 authors = ["shimunn <shimun@shimun.net>"]
 edition = "2018"
 
-[dependencies]
+description = "Decrypt your LUKS partition using a FIDO2 compatible authenticator"
-ctap = { git = "https://github.com/shimunn/ctap.git", branch = "hmac_ext" }
+documentation = "https://github.com/shimunn/fido2luks/blob/master/README.md"
-cryptsetup-rs = "0.2.0"
+homepage = "https://github.com/shimunn/fido2luks"
-hex = "0.3.2"
+repository = "https://github.com/shimunn/fido2luks"
-rust-crypto = "0.2.36"
+readme = "README.md"
-failure = "0.1.5"
+keywords = ["luks", "fido2", "u2f"]
-serde_derive = "1.0.100"
+categories = ["command-line-utilities"]
-serde = "1.0.100"
+license-file = "LICENSE"
-serde_json = "1.0.40"
-keyutils = "0.2.1"
-rpassword = "4.0.1"
-envy = "0.4.0"
 
+[dependencies]
+ctap_hmac = { version="0.4.2", features = ["request_multiple"] }
+hex = "0.3.2"
+ring = "0.13.5"
+failure = "0.1.5"
+rpassword = "4.0.1"
+structopt = "0.3.2"
+libcryptsetup-rs = "0.2.0"
 
 [profile.release]
 lto = true
 opt-level = 'z'
 panic = 'abort'
+incremental = false
+overflow-checks = false

README.md

@@ -1,33 +1,43 @@
-# fido2luks
+# fido2luks [![Crates.io Version](https://img.shields.io/crates/v/fido2luks.svg)](https://crates.io/crates/fido2luks)
 
-This will allow you to unlock your luks encrypted disk with an fido2 compatable key
+This will allow you to unlock your luks encrypted disk with an fido2 compatible key
 
-Note: This has only been tested under Fedora 30 using a Solo Key
+Note: This has only been tested under Fedora 31 using a Solo Key, Trezor Model T
 
 ## Setup
 
-## Device
+### Prerequisites
+
+```
+dnf install clang cargo cryptsetup-devel -y
+```
+
+### Device
 
 ```
 git clone https://github.com/shimunn/fido2luks.git && cd fido2luks
 
-#Alternativly cargo build --release && sudo cp target/release/fido2luks /usr/bin/
+# Alternativly cargo build --release && sudo cp target/release/fido2luks /usr/bin/
-CARGO_INSTALL_ROOT=/usr sudo -E cargo install -f --path .
+sudo -E cargo install -f --path . --root /usr
 
-echo FIDO2LUKS_CREDENTIAL_ID=$(fido2luks credential) >> fido2luks.conf
+# Copy template
+cp dracut/96luks-2fa/fido2luks.conf /etc/
+# Name is optional but useful if your authenticator has a display
+echo FIDO2LUKS_CREDENTIAL_ID=$(fido2luks credential [NAME]) >> /etc/fido2luks.conf
 
+# Load config into env
 set -a
-. fido2luks.conf
+. /etc/fido2luks.conf
 
-#Repeat for each luks volume
+# Repeat for each luks volume
-FIDO2LUKS_PASSWORD_HELPER=stdin sudo -E fido2luks addkey /dev/disk/by-uuid/<DISK_UUID>
+sudo -E fido2luks -i add-key /dev/disk/by-uuid/<DISK_UUID>
 
-#Test(only works if the luks container isn't active)
+# Test(only works if the luks container isn't active)
-FIDO2LUKS_PASSWORD_HELPER=stdin sudo -E fido2luks open /dev/disk/by-uuid/<DISK_UUID> luks-<DISK_UUID>
+sudo -E fido2luks -i open /dev/disk/by-uuid/<DISK_UUID> luks-<DISK_UUID>
 
 ```
 
-## Dracut
+### Dracut
 
 ```
 cd dracut
@@ -35,24 +45,61 @@ cd dracut
 sudo make install
 ```
 
-## Grub
+### Grub
 
-Add `rd.luks.2fa=<CREDENTIAL_ID>:<DISK_UUID>` to `GRUB_CMDLINE_LINUX`
+Add `rd.luks.2fa=<CREDENTIAL_ID>:<DISK_UUID>` to `GRUB_CMDLINE_LINUX` in /etc/default/grub
 
-Note: This is only required for your root disk, systemd will try to unlock all other luks partions using the same key if you added it using `fido2luks addkey`
+Note: This is only required for your root disk, systemd will try to unlock all other LUKS partions using the same key if you added it using `fido2luks add-key`
 
 ```
 grub2-mkconfig > /boot/grub2/grub.cfg
 ```
 
+I'd also recommend to copy the executable onto /boot so that it is accessible in case you have to access your disk from a rescue system
+
+```
+mkdir /boot/fido2luks/
+cp /usr/bin/fido2luks /boot/fido2luks/
+cp /etc/fido2luks.conf /boot/fido2luks/
+```
+
 ## Test
 
-Just reboot and see if it works, if thats the case you should remove your old less secure password from your luks header:
+Just reboot and see if it works, if that's the case you should remove your old less secure password from your LUKS header:
 
 ```
-#Recommend in case you lose your authenticator, store this backupfile somewhere safe
+# Recommend in case you lose your authenticator, store this backupfile somewhere safe
 cryptsetup luksHeaderBackup /dev/disk/by-uuid/<DISK_UUID> --header-backup-file luks_backup_<DISK_UUID>
-#Slot should be 0 if you only had one previous password otherwise consult cryptsetup luksDump
+# There is no turning back if you mess this up, make sure you made a backup
-#There is no turning back if you mess this up, make sure you made a backup
+fido2luks -i add-key --exclusive /dev/disk/by-uuid/<DISK_UUID>
-cryptsetup luksKillSlot /dev/disk/by-uuid/<DISK_UUID> <SLOT>
+```
+
+## Addtional settings
+
+### Password less
+
+Remove your previous secret as described in the next section, in case you've already added one.
+
+Open `/etc/fido2luks.conf` and replace `FIDO2LUKS_SALT=Ask` with `FIDO2LUKS_SALT=string:<YOUR_RANDOM_STRING>`
+but be warned that this password will be included to into your initramfs.
+
+Import the new config into env:
+
+```
+set -a
+. /etc/fido2luks.conf
+```
+
+Then add the new secret to each device and update dracut afterwards `dracut -f`
+
+## Removal
+
+Remove `rd.luks.2fa` from `GRUB_CMDLINE_LINUX` in /etc/default/grub
+
+```
+set -a
+. fido2luks.conf
+sudo -E fido2luks -i replace-key /dev/disk/by-uuid/<DISK_UUID>
+
+sudo rm -rf /usr/lib/dracut/modules.d/96luks-2fa /etc/dracut.conf.d/luks-2fa.conf /etc/fido2luks.conf
 ```

dracut/96luks-2fa/fido2luks.conf

@@ -0,0 +1,3 @@
+FIDO2LUKS_SALT=Ask
+FIDO2LUKS_PASSWORD_HELPER=/usr/bin/systemd-ask-password Please enter second factor for LUKS disk encryption
+

dracut/96luks-2fa/luks-2fa-generator.sh

@@ -5,11 +5,11 @@ LUKS_2FA_WANTS="/etc/systemd/system/luks-2fa.target.wants"
 
 CRYPTSETUP="/usr/lib/systemd/systemd-cryptsetup"
 FIDO2LUKS="/usr/bin/fido2luks"
-XXD="/usr/bin/xxd"
 MOUNT=$(command -v mount)
 UMOUNT=$(command -v umount)
 
-TIMEOUT=30
+TIMEOUT=120
+CON_MSG="Please connect your authenticator"
 
 generate_service () {
         local credential_id=$1 target_uuid=$2 timeout=$3 sd_dir=${4:-$NORMAL_DIR}
@@ -19,28 +19,27 @@ generate_service () {
 
         local crypto_target_service="systemd-cryptsetup@luks\x2d${sd_target_uuid}.service"
         local sd_service="${sd_dir}/luks-2fa@luks\x2d${sd_target_uuid}.service"
+        local fido2luks_args="--bin"
+        if [ ! -z "$timeout" ]; then
+          fido2luks_args="$fido2luks_args --await-dev ${timeout}"
+        fi
         {
                 printf -- "[Unit]"
                 printf -- "\nDescription=%s" "2fa for luks"
                 printf -- "\nBindsTo=%s" "$target_dev"
-                printf -- "\nAfter=%s cryptsetup-pre.target systemd-journald.socket" "$target_dev" #TODO: create service to wait or authenicator
+                printf -- "\nAfter=%s cryptsetup-pre.target systemd-journald.socket" "$target_dev"
                 printf -- "\nBefore=%s umount.target luks-2fa.target" "$crypto_target_service"
                 printf -- "\nConflicts=umount.target"
                 printf -- "\nDefaultDependencies=no"
-                printf -- "\nJobTimeoutSec=%s" "$timeout"
+                [ ! -z "$timeout" ] && printf -- "\nJobTimeoutSec=%s" "$timeout"
-
                 printf -- "\n\n[Service]"
                 printf -- "\nType=oneshot"
                 printf -- "\nRemainAfterExit=yes"
-                printf -- "\nEnvironment=FIDO2LUKS_CREDENTIAL_ID='%s'" "$credential_id"
+                printf -- "\nEnvironmentFile=%s" "/etc/fido2luks.conf"
-                printf -- "\nEnvironment=FIDO2LUKS_SALT='%s'" "Ask"
+                [ ! -z "$credential_id" ] && printf -- "\nEnvironment=FIDO2LUKS_CREDENTIAL_ID='%s'" "$credential_id"
-                printf -- "\nEnvironment=FIDO2LUKS_PASSWORD_HELPER='%s'" "/usr/bin/systemd-ask-password \"Disk 2fa password\""
                 printf -- "\nKeyringMode=%s" "shared"
-                #printf -- "\nExecStart=${CRYPTSETUP} attach 'luks-%s' '/dev/disk/by-uuid/%s' 'none'" "$keyfile_uuid" "$keyfile_uuid"   #LUKS on USB
+		            printf -- "\nExecStartPre=-/usr/bin/plymouth display-message --text \"${CON_MSG}\""
-                #printf -- "\nExecStart=${MOUNT} '/dev/mapper/luks-%s' %s" "$keyfile_uuid" "$keyfile_mountpoint"                        #Mount keyfile
+                printf -- "\nExecStart=/bin/bash -c \"${FIDO2LUKS} print-secret $fido2luks_args | ${CRYPTSETUP} attach 'luks-%s' '/dev/disk/by-uuid/%s' '/dev/stdin'\"" "$target_uuid" "$target_uuid"
-                printf -- "\nExecStart=/bin/bash -c \"${FIDO2LUKS} print-secret | ${XXD} -r -p - | ${CRYPTSETUP} attach 'luks-%s' '/dev/disk/by-uuid/%s' '/dev/stdin'\"" "$target_uuid" "$target_uuid"
-                #printf -- "\nExecStart=${UMOUNT} '%s'" "$keyfile_mountpoint"
-                #printf -- "\nExecStart=${CRYPTSETUP} detach 'luks-%s'" "$keyfile_uuid"
                 printf -- "\nExecStop=${CRYPTSETUP} detach 'luks-%s'" "$target_uuid"
         } > "$sd_service"
 

dracut/96luks-2fa/module-setup.sh

@@ -17,8 +17,8 @@ depends () {
 
 install () {
         inst "$moddir/luks-2fa-generator.sh" "/etc/systemd/system-generators/luks-2fa-generator.sh"
-        inst_simple "/usr/bin/xxd" "/usr/bin/xxd"
         inst_simple "/usr/bin/fido2luks" "/usr/bin/fido2luks"
+        inst_simple "/etc/fido2luks.conf" "/etc/fido2luks.conf"
         inst "$systemdutildir/systemd-cryptsetup"
         mkdir -p "$initdir/luks-2fa"
 

dracut/Makefile

@@ -15,6 +15,7 @@ help:
 install:
 	cp ${MODULE_CONF_D}/${MODULE_CONF} ${DRACUT_CONF_D}/
 	cp -r ${MODULE_DIR} ${DRACUT_MODULES_D}/
+	cp ${MODULE_DIR}/fido2luks.conf /etc/fido2luks.conf
 	dracut -fv
 clean:
 	rm ${DRACUT_CONF_D}/${MODULE_CONF}

src/cli.rs

@@ -1,121 +1,494 @@
 use crate::error::*;
+use crate::luks;
 use crate::*;
 
-use cryptsetup_rs as luks;
+use structopt::StructOpt;
-use cryptsetup_rs::api::{CryptDeviceHandle, CryptDeviceOpenBuilder, Luks1Params};
-use cryptsetup_rs::Luks1CryptDevice;
-use ctap;
-use ctap::extensions::hmac::{FidoHmacCredential, HmacExtension};
-use ctap::FidoDevice;
 
-use std::fs::File;
+use ctap::{FidoCredential, FidoErrorKind};
-use std::io::{Read, Write};
+use failure::_core::fmt::{Display, Error, Formatter};
-use std::path::Path;
+use failure::_core::str::FromStr;
+use failure::_core::time::Duration;
+use std::io::Write;
+use std::process::exit;
 use std::thread;
-use std::time::Duration;
 
-pub fn setup() -> Fido2LuksResult<()> {
+use crate::util::sha256;
-    while !authenticator_connected()? {
+use std::time::SystemTime;
-        eprintln!("Please connect your authenticator");
+
-        for _ in 0..3 {
+#[derive(Debug, Eq, PartialEq, Clone)]
-            thread::sleep(Duration::from_secs(1));
+pub struct HexEncoded(pub Vec<u8>);
-            if authenticator_connected()? {
+
-                break;
+impl Display for HexEncoded {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        f.write_str(&hex::encode(&self.0))
     }
+}
+
+impl FromStr for HexEncoded {
+    type Err = hex::FromHexError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(HexEncoded(hex::decode(s)?))
     }
+}
+
+#[derive(Debug, Eq, PartialEq, Clone)]
+pub struct CommaSeparated<T: FromStr + Display>(pub Vec<T>);
+
+impl<T: Display + FromStr> Display for CommaSeparated<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        for i in &self.0 {
+            f.write_str(&i.to_string())?;
+            f.write_str(",")?;
         }
-
-    let mut config = Config::default();
-
-    let save_config = |c: &Config| {
-        File::create("fido2luks.json")
-            .expect("Failed to save config")
-            .write_all(serde_json::to_string_pretty(c).unwrap().as_bytes())
-            .expect("Failed to save config");
-    };
-
-    fn ask_bool(q: &str) -> bool {
-        ask_str(&format!("{} (y/n)", q)).expect("Failed to read from stdin") == "y"
-    }
-
-    println!("1. Generating a credential");
-    let mut ccred: Option<FidoHmacCredential> = None;
-    for di in ctap::get_devices().expect("Failed to query USB for 2fa devices") {
-        let mut dev = FidoDevice::new(&di).expect("Failed to open 2fa device");
-        match dev.make_hmac_credential() {
-            Ok(cred) => {
-                ccred = Some(cred);
-                break;
-            }
-            Err(_e) => println!("Failed to to obtain credential trying next device(if applicable)"),
-        }
-    }
-    config.credential_id = hex::encode(ccred.expect("No credential could be obtained").id);
-    save_config(&config);
-
-    loop {
-        let device = ask_str("Path to your luks device: ").expect("Failed to read from stdin");;
-        if Path::new(&device).exists()
-            || ask_bool(&format!("{} does not exist, save anyway?", device))
-        {
-            config.device = device.into();
-            break;
-        }
-    }
-
-    save_config(&config);
-
-    config.mapper_name = ask_str("Name for decrypted disk: ").expect("Failed to read from stdin");;
-
-    save_config(&config);
-
-    println!("Config saved to: fido2luks.json");
-
-    //let slot = add_key_to_luks(&config).expect("Failed to add key to device");
-
-    //println!("Added key to slot: {}", slot);
-
         Ok(())
-}
-
-pub fn add_key_to_luks(device: PathBuf, secret: &[u8; 32]) -> Fido2LuksResult<u8> {
-    fn offer_format(
-        _dev: CryptDeviceOpenBuilder,
-    ) -> Fido2LuksResult<CryptDeviceHandle<Luks1Params>> {
-        unimplemented!()
     }
-    let dev =
+}
-        || -> luks::device::Result<CryptDeviceOpenBuilder> { luks::open(&device.canonicalize()?) };
 
-    let prev_key_info = rpassword::read_password_from_tty(Some(
+impl<T: Display + FromStr> FromStr for CommaSeparated<T> {
-        "Please enter your current password or path to a keyfile in order to add a new key: ",
+    type Err = <T as FromStr>::Err;
-    ))?;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
-
+        Ok(CommaSeparated(
-    let prev_key = match prev_key_info.as_ref() {
+            s.split(',')
-        "" => None,
+                .map(|part| <T as FromStr>::from_str(part))
-        keyfile if PathBuf::from(keyfile).exists() => {
+                .collect::<Result<Vec<_>, _>>()?,
-            let mut f = File::open(keyfile)?;
+        ))
-            let mut key = Vec::new();
-            f.read_to_end(&mut key)?;
-            Some(key)
     }
-        password => Some(Vec::from(password.as_bytes())),
-    };
-
-    let mut handle = match dev()?.luks1() {
-        Ok(handle) => handle,
-        Err(luks::device::Error::BlkidError(_)) => offer_format(dev()?)?,
-        Err(luks::device::Error::CryptsetupError(errno)) => {
-            //if i32::from(errno) == 555
-            dbg!(errno);
-            offer_format(dev()?)?
-        } //TODO: find correct errorno and offer to format as luks
-        err => err?,
-    };
-    let slot = handle.add_keyslot(secret, prev_key.as_ref().map(|b| b.as_slice()), None)?;
-    Ok(slot)
 }
 
-pub fn authenticator_connected() -> Fido2LuksResult<bool> {
+#[derive(Debug, StructOpt)]
-    Ok(!device::get_devices()?.is_empty())
+pub struct Credentials {
+    /// FIDO credential ids, seperated by ',' generate using fido2luks credential
+    #[structopt(name = "credential-id", env = "FIDO2LUKS_CREDENTIAL_ID")]
+    pub ids: CommaSeparated<HexEncoded>,
+}
+
+#[derive(Debug, StructOpt)]
+pub struct AuthenticatorParameters {
+    /// Request a PIN to unlock the authenticator
+    #[structopt(short = "P", long = "pin")]
+    pub pin: bool,
+
+    /// Await for an authenticator to be connected, timeout after n seconds
+    #[structopt(
+        long = "await-dev",
+        name = "await-dev",
+        env = "FIDO2LUKS_DEVICE_AWAIT",
+        default_value = "15"
+    )]
+    pub await_time: u64,
+}
+
+#[derive(Debug, StructOpt)]
+pub struct LuksParameters {
+    #[structopt(env = "FIDO2LUKS_DEVICE")]
+    device: PathBuf,
+
+    /// Try to unlock the device using a specifc keyslot, ignore all other slots
+    #[structopt(long = "slot", env = "FIDO2LUKS_DEVICE_SLOT")]
+    slot: Option<u32>,
+}
+
+#[derive(Debug, StructOpt, Clone)]
+pub struct LuksModParameters {
+    /// Number of milliseconds required to derive the volume decryption key
+    /// Defaults to 10ms when using an authenticator or the default by cryptsetup when using a password
+    #[structopt(long = "kdf-time", name = "kdf-time")]
+    kdf_time: Option<u64>,
+}
+
+#[derive(Debug, StructOpt)]
+pub struct SecretParameters {
+    /// Salt for secret generation, defaults to 'ask'
+    ///
+    /// Options:{n}
+    ///  - ask              : Prompt user using password helper{n}
+    ///  - file:<PATH>      : Will read <FILE>{n}
+    ///  - string:<STRING>  : Will use <STRING>, which will be handled like a password provided to the 'ask' option{n}
+    #[structopt(
+        name = "salt",
+        long = "salt",
+        env = "FIDO2LUKS_SALT",
+        default_value = "ask"
+    )]
+    pub salt: InputSalt,
+    /// Script used to obtain passwords, overridden by --interactive flag
+    #[structopt(
+        name = "password-helper",
+        env = "FIDO2LUKS_PASSWORD_HELPER",
+        default_value = "/usr/bin/env systemd-ask-password 'Please enter second factor for LUKS disk encryption!'"
+    )]
+    pub password_helper: PasswordHelper,
+}
+
+fn derive_secret(
+    credentials: &[HexEncoded],
+    salt: &[u8; 32],
+    timeout: u64,
+    pin: Option<&str>,
+) -> Fido2LuksResult<[u8; 32]> {
+    let timeout = Duration::from_secs(timeout);
+    let start = SystemTime::now();
+
+    while let Ok(el) = start.elapsed() {
+        if el > timeout {
+            return Err(error::Fido2LuksError::NoAuthenticatorError);
+        }
+        if get_devices()
+            .map(|devices| !devices.is_empty())
+            .unwrap_or(false)
+        {
+            break;
+        }
+        thread::sleep(Duration::from_millis(500));
+    }
+
+    Ok(sha256(&[
+        &perform_challenge(
+            &credentials
+                .iter()
+                .map(|hex| FidoCredential {
+                    id: hex.0.clone(),
+                    public_key: None,
+                })
+                .collect::<Vec<_>>()
+                .iter()
+                .collect::<Vec<_>>()[..],
+            salt,
+            timeout - start.elapsed().unwrap(),
+            pin,
+        )?[..],
+        salt,
+    ]))
+}
+
+fn read_pin() -> Fido2LuksResult<String> {
+    util::read_password("Authenticator PIN", false)
+}
+
+#[derive(Debug, StructOpt)]
+pub struct Args {
+    /// Request passwords via Stdin instead of using the password helper
+    #[structopt(short = "i", long = "interactive")]
+    pub interactive: bool,
+    #[structopt(subcommand)]
+    pub command: Command,
+}
+
+#[derive(Debug, StructOpt, Clone)]
+pub struct OtherSecret {
+    /// Use a keyfile instead of a password
+    #[structopt(short = "d", long = "keyfile", conflicts_with = "fido_device")]
+    keyfile: Option<PathBuf>,
+    /// Use another fido device instead of a password
+    /// Note: this requires for the credential fot the other device to be passed as argument as well
+    #[structopt(short = "f", long = "fido-device", conflicts_with = "keyfile")]
+    fido_device: bool,
+}
+
+#[derive(Debug, StructOpt)]
+pub enum Command {
+    #[structopt(name = "print-secret")]
+    PrintSecret {
+        /// Prints the secret as binary instead of hex encoded
+        #[structopt(short = "b", long = "bin")]
+        binary: bool,
+        #[structopt(flatten)]
+        credentials: Credentials,
+        #[structopt(flatten)]
+        authenticator: AuthenticatorParameters,
+        #[structopt(flatten)]
+        secret: SecretParameters,
+    },
+    /// Adds a generated key to the specified LUKS device
+    #[structopt(name = "add-key")]
+    AddKey {
+        #[structopt(flatten)]
+        luks: LuksParameters,
+        #[structopt(flatten)]
+        credentials: Credentials,
+        #[structopt(flatten)]
+        authenticator: AuthenticatorParameters,
+        #[structopt(flatten)]
+        secret: SecretParameters,
+        /// Will wipe all other keys
+        #[structopt(short = "e", long = "exclusive")]
+        exclusive: bool,
+        #[structopt(flatten)]
+        existing_secret: OtherSecret,
+        #[structopt(flatten)]
+        luks_mod: LuksModParameters,
+    },
+    /// Replace a previously added key with a password
+    #[structopt(name = "replace-key")]
+    ReplaceKey {
+        #[structopt(flatten)]
+        luks: LuksParameters,
+        #[structopt(flatten)]
+        credentials: Credentials,
+        #[structopt(flatten)]
+        authenticator: AuthenticatorParameters,
+        #[structopt(flatten)]
+        secret: SecretParameters,
+        /// Add the password and keep the key
+        #[structopt(short = "a", long = "add-password")]
+        add_password: bool,
+        #[structopt(flatten)]
+        replacement: OtherSecret,
+        #[structopt(flatten)]
+        luks_mod: LuksModParameters,
+    },
+    /// Open the LUKS device
+    #[structopt(name = "open")]
+    Open {
+        #[structopt(flatten)]
+        luks: LuksParameters,
+        #[structopt(env = "FIDO2LUKS_MAPPER_NAME")]
+        name: String,
+        #[structopt(flatten)]
+        credentials: Credentials,
+        #[structopt(flatten)]
+        authenticator: AuthenticatorParameters,
+        #[structopt(flatten)]
+        secret: SecretParameters,
+
+        #[structopt(short = "r", long = "max-retries", default_value = "0")]
+        retries: i32,
+    },
+    /// Generate a new FIDO credential
+    #[structopt(name = "credential")]
+    Credential {
+        #[structopt(flatten)]
+        authenticator: AuthenticatorParameters,
+        /// Name to be displayed on the authenticator if it has a display
+        #[structopt(env = "FIDO2LUKS_CREDENTIAL_NAME")]
+        name: Option<String>,
+    },
+    /// Check if an authenticator is connected
+    #[structopt(name = "connected")]
+    Connected,
+}
+
+pub fn parse_cmdline() -> Args {
+    Args::from_args()
+}
+
+pub fn run_cli() -> Fido2LuksResult<()> {
+    let mut stdout = io::stdout();
+    let args = parse_cmdline();
+    let interactive = args.interactive;
+    match &args.command {
+        Command::Credential {
+            authenticator,
+            name,
+        } => {
+            let pin_string;
+            let pin = if authenticator.pin {
+                pin_string = read_pin()?;
+                Some(pin_string.as_ref())
+            } else {
+                None
+            };
+            let cred = make_credential_id(name.as_ref().map(|n| n.as_ref()), pin)?;
+            println!("{}", hex::encode(&cred.id));
+            Ok(())
+        }
+        Command::PrintSecret {
+            binary,
+            authenticator,
+            credentials,
+            secret,
+        } => {
+            let pin_string;
+            let pin = if authenticator.pin {
+                pin_string = read_pin()?;
+                Some(pin_string.as_ref())
+            } else {
+                None
+            };
+            let salt = if interactive || secret.password_helper == PasswordHelper::Stdin {
+                util::read_password_hashed("Password", false)
+            } else {
+                secret.salt.obtain(&secret.password_helper)
+            }?;
+            let secret = derive_secret(
+                credentials.ids.0.as_slice(),
+                &salt,
+                authenticator.await_time,
+                pin,
+            )?;
+            if *binary {
+                stdout.write_all(&secret[..])?;
+            } else {
+                stdout.write_all(hex::encode(&secret[..]).as_bytes())?;
+            }
+            Ok(stdout.flush()?)
+        }
+        Command::AddKey {
+            luks,
+            authenticator,
+            credentials,
+            secret,
+            luks_mod,
+            existing_secret: other_secret,
+            ..
+        }
+        | Command::ReplaceKey {
+            luks,
+            authenticator,
+            credentials,
+            secret,
+            luks_mod,
+            replacement: other_secret,
+            ..
+        } => {
+            let pin = if authenticator.pin {
+                Some(read_pin()?)
+            } else {
+                None
+            };
+            let salt = |q: &str, verify: bool| -> Fido2LuksResult<[u8; 32]> {
+                if interactive || secret.password_helper == PasswordHelper::Stdin {
+                    util::read_password_hashed(q, verify)
+                } else {
+                    secret.salt.obtain(&secret.password_helper)
+                }
+            };
+            let other_secret = |salt_q: &str, verify: bool| -> Fido2LuksResult<Vec<u8>> {
+                match other_secret {
+                    OtherSecret {
+                        keyfile: Some(file),
+                        ..
+                    } => util::read_keyfile(file),
+                    OtherSecret {
+                        fido_device: true, ..
+                    } => Ok(derive_secret(
+                        &credentials.ids.0,
+                        &salt(salt_q, verify)?,
+                        authenticator.await_time,
+                        pin.as_deref(),
+                    )?[..]
+                        .to_vec()),
+                    _ => Ok(util::read_password(salt_q, verify)?.as_bytes().to_vec()),
+                }
+            };
+            let secret = |verify: bool| -> Fido2LuksResult<[u8; 32]> {
+                derive_secret(
+                    &credentials.ids.0,
+                    &salt("Password", verify)?,
+                    authenticator.await_time,
+                    pin.as_deref(),
+                )
+            };
+            // Non overlap
+            match &args.command {
+                Command::AddKey { exclusive, .. } => {
+                    let existing_secret = other_secret("Current password", false)?;
+                    let new_secret = secret(true)?;
+                    let added_slot = luks::add_key(
+                        &luks.device,
+                        &new_secret,
+                        &existing_secret[..],
+                        luks_mod.kdf_time.or(Some(10)),
+                    )?;
+                    if *exclusive {
+                        let destroyed = luks::remove_keyslots(&luks.device, &[added_slot])?;
+                        println!(
+                            "Added to key to device {}, slot: {}\nRemoved {} old keys",
+                            luks.device.display(),
+                            added_slot,
+                            destroyed
+                        );
+                    } else {
+                        println!(
+                            "Added to key to device {}, slot: {}",
+                            luks.device.display(),
+                            added_slot
+                        );
+                    }
+                    Ok(())
+                }
+                Command::ReplaceKey { add_password, .. } => {
+                    let existing_secret = secret(false)?;
+                    let replacement_secret = other_secret("Replacement password", true)?;
+                    let slot = if *add_password {
+                        luks::add_key(
+                            &luks.device,
+                            &replacement_secret[..],
+                            &existing_secret,
+                            luks_mod.kdf_time,
+                        )
+                    } else {
+                        luks::replace_key(
+                            &luks.device,
+                            &replacement_secret[..],
+                            &existing_secret,
+                            luks_mod.kdf_time,
+                        )
+                    }?;
+                    println!(
+                        "Added to password to device {}, slot: {}",
+                        luks.device.display(),
+                        slot
+                    );
+                    Ok(())
+                }
+                _ => unreachable!(),
+            }
+        }
+        Command::Open {
+            luks,
+            authenticator,
+            credentials,
+            secret,
+            name,
+            retries,
+        } => {
+            let pin_string;
+            let pin = if authenticator.pin {
+                pin_string = read_pin()?;
+                Some(pin_string.as_ref())
+            } else {
+                None
+            };
+            let salt = |q: &str, verify: bool| -> Fido2LuksResult<[u8; 32]> {
+                if interactive || secret.password_helper == PasswordHelper::Stdin {
+                    util::read_password_hashed(q, verify)
+                } else {
+                    secret.salt.obtain(&secret.password_helper)
+                }
+            };
+            let mut retries = *retries;
+            loop {
+                match derive_secret(
+                    &credentials.ids.0,
+                    &salt("Password", false)?,
+                    authenticator.await_time,
+                    pin,
+                )
+                .and_then(|secret| luks::open_container(&luks.device, &name, &secret, luks.slot))
+                {
+                    Err(e) => {
+                        match e {
+                            Fido2LuksError::WrongSecret if retries > 0 => {}
+                            Fido2LuksError::AuthenticatorError { ref cause }
+                                if cause.kind() == FidoErrorKind::Timeout && retries > 0 => {}
+
+                            e => return Err(e),
+                        }
+                        retries -= 1;
+                        eprintln!("{}", e);
+                    }
+                    res => break res,
+                }
+            }
+        }
+        Command::Connected => match get_devices() {
+            Ok(ref devs) if !devs.is_empty() => {
+                println!("Found {} devices", devs.len());
+                Ok(())
+            }
+            _ => exit(1),
+        },
+    }
 }

src/config.rs

@@ -1,94 +1,19 @@
 use crate::error::*;
 use crate::*;
-use crypto::digest::Digest;
+use ring::digest;
-use crypto::sha2::Sha256;
 
-use serde_derive::{Deserialize, Serialize};
+use std::fmt;
-use std::collections::HashMap;
-use std::convert::TryInto;
-use std::env;
 use std::fs::File;
 use std::io::Read;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::process::Command;
+use std::str::FromStr;
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Clone, PartialEq)]
-pub struct EnvConfig {
-    pub credential_id: String,
-    pub device: Option<String>,
-    pub salt: String,
-    pub mapper_name: Option<String>,
-    pub password_helper: String,
-}
-
-impl TryInto<Config> for EnvConfig {
-    type Error = Fido2LuksError;
-
-    fn try_into(self) -> Fido2LuksResult<Config> {
-        Ok(Config {
-            credential_id: self.credential_id,
-            device: self
-                .device
-                .ok_or(Fido2LuksError::ConfigurationError {
-                    cause: ConfigurationError::MissingField("DEVICE".into()),
-                })?
-                .into(),
-            mapper_name: self.mapper_name.ok_or(Fido2LuksError::ConfigurationError {
-                cause: ConfigurationError::MissingField("DEVICE_MAPPER".into()),
-            })?,
-            password_helper: PasswordHelper::Script(self.password_helper),
-            input_salt: self.salt.as_str().into(),
-        })
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct Config {
-    pub credential_id: String,
-    pub input_salt: InputSalt,
-    pub device: PathBuf,
-    pub mapper_name: String,
-    pub password_helper: PasswordHelper,
-}
-
-impl Config {
-    pub fn load_default_location() -> Fido2LuksResult<Config> {
-        Self::load_config(
-            &mut File::open(
-                env::vars()
-                    .collect::<HashMap<_, _>>()
-                    .get("FIDO2LUKS_CONFIG")
-                    .unwrap_or(&"/etc/fido2luks.json".to_owned()),
-            )
-            .or(File::open("fido2luks.json"))?,
-        )
-    }
-
-    pub fn load_config(reader: &mut dyn Read) -> Fido2LuksResult<Config> {
-        let mut conf_str = String::new();
-        reader.read_to_string(&mut conf_str)?;
-
-        Ok(serde_json::from_str(&conf_str)?)
-    }
-}
-
-impl Default for Config {
-    fn default() -> Self {
-        Config {
-            credential_id: "<required>".into(),
-            input_salt: Default::default(),
-            device: "/dev/some-vg/<volume>".into(),
-            mapper_name: "2fa-secured-luks".into(),
-            password_helper: PasswordHelper::default(),
-        }
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
 pub enum InputSalt {
     AskPassword,
+    String(String),
     File { path: PathBuf },
-    Both { path: PathBuf },
 }
 
 impl Default for InputSalt {
@@ -99,17 +24,39 @@ impl Default for InputSalt {
 
 impl From<&str> for InputSalt {
     fn from(s: &str) -> Self {
-        if PathBuf::from(s).exists() && s != "Ask" {
+        let mut parts = s.split(':');
-            InputSalt::File { path: s.into() }
+        match parts.next() {
-        } else {
+            Some("ask") | Some("Ask") => InputSalt::AskPassword,
-            InputSalt::AskPassword
+            Some("file") => InputSalt::File {
+                path: parts.collect::<Vec<_>>().join(":").into(),
+            },
+            Some("string") => InputSalt::String(parts.collect::<Vec<_>>().join(":")),
+            _ => Self::default(),
         }
     }
 }
 
+impl FromStr for InputSalt {
+    type Err = Fido2LuksError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self::from(s))
+    }
+}
+
+impl fmt::Display for InputSalt {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        f.write_str(&match self {
+            InputSalt::AskPassword => "ask".to_string(),
+            InputSalt::String(s) => ["string", s].join(":"),
+            InputSalt::File { path } => ["file", path.display().to_string().as_str()].join(":"),
+        })
+    }
+}
+
 impl InputSalt {
     pub fn obtain(&self, password_helper: &PasswordHelper) -> Fido2LuksResult<[u8; 32]> {
-        let mut digest = Sha256::new();
+        let mut digest = digest::Context::new(&digest::SHA256);
         match self {
             InputSalt::File { path } => {
                 let mut do_io = || {
@@ -117,7 +64,7 @@ impl InputSalt {
                     let mut buf = [0u8; 512];
                     loop {
                         let red = reader.read(&mut buf)?;
-                        digest.input(&buf[0..red]);
+                        digest.update(&buf[0..red]);
                         if red == 0 {
                             break;
                         }
@@ -127,29 +74,30 @@ impl InputSalt {
                 do_io().map_err(|cause| Fido2LuksError::KeyfileError { cause })?;
             }
             InputSalt::AskPassword => {
-                digest.input(password_helper.obtain()?.as_bytes());
+                digest.update(password_helper.obtain()?.as_bytes());
-            }
-            InputSalt::Both { path } => {
-                digest.input(&InputSalt::AskPassword.obtain(password_helper)?);
-                digest.input(&InputSalt::File { path: path.clone() }.obtain(password_helper)?)
             }
+            InputSalt::String(s) => digest.update(s.as_bytes()),
         }
         let mut salt = [0u8; 32];
-        digest.result(&mut salt);
+        salt.as_mut().copy_from_slice(digest.finish().as_ref());
         Ok(salt)
     }
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum PasswordHelper {
     Script(String),
+    #[allow(dead_code)]
     Systemd,
     Stdin,
 }
 
 impl Default for PasswordHelper {
     fn default() -> Self {
-        PasswordHelper::Script("/usr/bin/systemd-ask-password --no-tty 'Please enter second factor for LUKS disk encryption!'".into())
+        PasswordHelper::Script(
+            "/usr/bin/env systemd-ask-password 'Please enter second factor for LUKS disk encryption!'"
+                .into(),
+        )
     }
 }
 
@@ -162,22 +110,77 @@ impl From<&str> for PasswordHelper {
     }
 }
 
+impl FromStr for PasswordHelper {
+    type Err = Fido2LuksError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self::from(s))
+    }
+}
+
+impl fmt::Display for PasswordHelper {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        f.write_str(&match self {
+            PasswordHelper::Stdin => "stdin".to_string(),
+            PasswordHelper::Systemd => "systemd".to_string(),
+            PasswordHelper::Script(path) => path.clone(),
+        })
+    }
+}
+
 impl PasswordHelper {
     pub fn obtain(&self) -> Fido2LuksResult<String> {
         use PasswordHelper::*;
         match self {
             Systemd => unimplemented!(),
-            Stdin => Ok(rpassword::read_password_from_tty(Some("Password: "))?),
+            Stdin => Ok(util::read_password("Password", true)?),
             Script(password_helper) => {
-                let mut helper_parts = password_helper.split(" ");
+                let mut helper_parts = password_helper.split(' ');
 
                 let password = Command::new((&mut helper_parts).next().unwrap())
                     .args(helper_parts)
                     .output()
-                    .map_err(|e| Fido2LuksError::AskPassError { cause: e })?
+                    .map_err(|e| Fido2LuksError::AskPassError {
+                        cause: error::AskPassError::IO(e),
+                    })?
                     .stdout;
                 Ok(String::from_utf8(password)?.trim().to_owned())
             }
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+
+    use super::*;
+
+    #[test]
+    fn input_salt_from_str() {
+        assert_eq!(
+            "file:/tmp/abc".parse::<InputSalt>().unwrap(),
+            InputSalt::File {
+                path: "/tmp/abc".into()
+            }
+        );
+        assert_eq!(
+            "string:abc".parse::<InputSalt>().unwrap(),
+            InputSalt::String("abc".into())
+        );
+        assert_eq!("ask".parse::<InputSalt>().unwrap(), InputSalt::AskPassword);
+        assert_eq!("lol".parse::<InputSalt>().unwrap(), InputSalt::default());
+    }
+
+    #[test]
+    fn input_salt_obtain() {
+        assert_eq!(
+            InputSalt::String("abc".into())
+                .obtain(&PasswordHelper::Stdin)
+                .unwrap(),
+            [
+                186, 120, 22, 191, 143, 1, 207, 234, 65, 65, 64, 222, 93, 174, 34, 35, 176, 3, 97,
+                163, 150, 23, 122, 156, 180, 16, 255, 97, 242, 0, 21, 173
+            ]
+        )
+    }
+}

src/device.rs

@@ -1,51 +1,61 @@
 use crate::error::*;
 
-use ctap;
+use crate::util;
-use ctap::extensions::hmac::{FidoHmacCredential, HmacExtension};
+use ctap::{
-use ctap::{FidoDevice, FidoError, FidoErrorKind};
+    self, extensions::hmac::HmacExtension, request_multiple_devices, FidoAssertionRequestBuilder,
+    FidoCredential, FidoCredentialRequestBuilder, FidoDevice, FidoError, FidoErrorKind,
+};
+use std::time::Duration;
 
-pub fn make_credential_id() -> Fido2LuksResult<FidoHmacCredential> {
+const RP_ID: &str = "fido2luks";
-    let mut errs = Vec::new();
+
-    match get_devices()? {
+pub fn make_credential_id(
-        ref devs if devs.is_empty() => Err(Fido2LuksError::NoAuthenticatorError)?,
+    name: Option<&str>,
-        devs => {
+    pin: Option<&str>,
-            for mut dev in devs.into_iter() {
+) -> Fido2LuksResult<FidoCredential> {
-                match dev.make_hmac_credential() {
+    let mut request = FidoCredentialRequestBuilder::default().rp_id(RP_ID);
-                    Ok(cred) => {
+    if let Some(user_name) = name {
-                        return Ok(cred);
+        request = request.user_name(user_name);
     }
-                    Err(e) => {
+    let request = request.build().unwrap();
-                        errs.push(e);
+    let make_credential = |device: &mut FidoDevice| {
+        if let Some(pin) = pin {
+            device.unlock(pin)?;
         }
-                }
+        device.make_hmac_credential(&request)
-            }
+    };
-        }
+    Ok(request_multiple_devices(
-    }
+        get_devices()?
-    Err(errs.pop().ok_or(Fido2LuksError::NoAuthenticatorError)?)?
+            .iter_mut()
+            .map(|device| (device, &make_credential)),
+        None,
+    )?)
 }
 
-pub fn perform_challenge(credential_id: &str, salt: &[u8; 32]) -> Fido2LuksResult<[u8; 32]> {
+pub fn perform_challenge(
-    let cred = FidoHmacCredential {
+    credentials: &[&FidoCredential],
-        id: hex::decode(credential_id).unwrap(),
+    salt: &[u8; 32],
-        rp_id: "hmac".to_string(),
+    timeout: Duration,
+    pin: Option<&str>,
+) -> Fido2LuksResult<[u8; 32]> {
+    let request = FidoAssertionRequestBuilder::default()
+        .rp_id(RP_ID)
+        .credentials(credentials)
+        .build()
+        .unwrap();
+    let get_assertion = |device: &mut FidoDevice| {
+        if let Some(pin) = pin {
+            device.unlock(pin)?;
+        }
+        device.get_hmac_assertion(&request, &util::sha256(&[&salt[..]]), None)
     };
-    let mut errs = Vec::new();
+    let (_, (secret, _)) = request_multiple_devices(
-    match get_devices()? {
+        get_devices()?
-        ref devs if devs.is_empty() => Err(Fido2LuksError::NoAuthenticatorError)?,
+            .iter_mut()
-        devs => {
+            .map(|device| (device, &get_assertion)),
-            for mut dev in devs.into_iter() {
+        Some(timeout),
-                match dev.hmac_challange(&cred, &salt[..]) {
+    )?;
-                    Ok(secret) => {
+    Ok(secret)
-                        return Ok(secret);
-                    }
-                    Err(e) => {
-                        errs.push(e);
-                    }
-                }
-            }
-        }
-    }
-    Err(errs.pop().ok_or(Fido2LuksError::NoAuthenticatorError)?)?
 }
 
 pub fn get_devices() -> Fido2LuksResult<Vec<FidoDevice>> {
@@ -54,7 +64,7 @@ pub fn get_devices() -> Fido2LuksResult<Vec<FidoDevice>> {
         match FidoDevice::new(&di) {
             Err(e) => match e.kind() {
                 FidoErrorKind::ParseCtap | FidoErrorKind::DeviceUnsupported => (),
-                err => Err(FidoError::from(err))?,
+                err => return Err(FidoError::from(err).into()),
             },
             Ok(dev) => devices.push(dev),
         }

src/error.rs

@@ -6,48 +6,47 @@ pub type Fido2LuksResult<T> = Result<T, Fido2LuksError>;
 #[derive(Debug, Fail)]
 pub enum Fido2LuksError {
     #[fail(display = "unable to retrieve password: {}", cause)]
-    AskPassError { cause: io::Error },
+    AskPassError { cause: AskPassError },
     #[fail(display = "unable to read keyfile: {}", cause)]
     KeyfileError { cause: io::Error },
     #[fail(display = "authenticator error: {}", cause)]
     AuthenticatorError { cause: ctap::FidoError },
-    #[fail(display = "no authenticator found, please ensure you device is plugged in")]
+    #[fail(display = "no authenticator found, please ensure your device is plugged in")]
     NoAuthenticatorError,
     #[fail(display = "luks err")]
-    LuksError { cause: cryptsetup_rs::device::Error },
+    LuksError {
-    #[fail(display = "no authenticator found, please ensure you device is plugged in")]
+        cause: libcryptsetup_rs::LibcryptErr,
+    },
+    #[fail(display = "no authenticator found, please ensure your device is plugged in")]
     IoError { cause: io::Error },
-    #[fail(display = "failed to parse config, please check formatting and contents")]
+    #[fail(display = "supplied secret isn't valid for this device")]
-    ConfigurationError { cause: ConfigurationError },
-    #[fail(display = "the submitted secret is not applicable to this luks device")]
     WrongSecret,
     #[fail(display = "not an utf8 string")]
     StringEncodingError { cause: FromUtf8Error },
 }
 
-#[derive(Debug)]
+impl Fido2LuksError {
-pub enum ConfigurationError {
+    pub fn exit_code(&self) -> i32 {
-    Json(serde_json::error::Error),
+        use Fido2LuksError::*;
-    Env(envy::Error),
+        match self {
-    MissingField(String),
+            AskPassError { .. } | KeyfileError { .. } => 2,
-}
+            AuthenticatorError { .. } => 3,
-
+            NoAuthenticatorError => 4,
-impl From<serde_json::error::Error> for Fido2LuksError {
+            WrongSecret => 5,
-    fn from(e: serde_json::error::Error) -> Self {
+            _ => 1,
-        Fido2LuksError::ConfigurationError {
-            cause: ConfigurationError::Json(e),
         }
     }
 }
 
-impl From<envy::Error> for Fido2LuksError {
+#[derive(Debug, Fail)]
-    fn from(e: envy::Error) -> Self {
+pub enum AskPassError {
-        Fido2LuksError::ConfigurationError {
+    #[fail(display = "unable to retrieve password: {}", _0)]
-            cause: ConfigurationError::Env(e),
+    IO(io::Error),
-        }
+    #[fail(display = "provided passwords don't match")]
-    }
+    Mismatch,
 }
 
+use libcryptsetup_rs::LibcryptErr;
 use std::string::FromUtf8Error;
 use Fido2LuksError::*;
 
@@ -57,12 +56,16 @@ impl From<FidoError> for Fido2LuksError {
     }
 }
 
-impl From<cryptsetup_rs::device::Error> for Fido2LuksError {
+impl From<LibcryptErr> for Fido2LuksError {
-    fn from(e: cryptsetup_rs::device::Error) -> Self {
+    fn from(e: LibcryptErr) -> Self {
-        LuksError { cause: e }
+        match e {
+            LibcryptErr::IOError(e) if e.raw_os_error().iter().any(|code| code == &1i32) => {
+                WrongSecret
+            }
+            _ => LuksError { cause: e },
+        }
     }
 }
-
 impl From<io::Error> for Fido2LuksError {
     fn from(e: io::Error) -> Self {
         IoError { cause: e }

src/keystore.rs

@@ -1,17 +0,0 @@
-use keyutils::Keyring;
-
-fn get_passphrase() -> Vec<u8> {
-    Keyring::request("user")
-        .unwrap()
-        .request_key("fido2luks")
-        .unwrap()
-        .read()
-        .unwrap()
-}
-
-fn add_secret(secret: &[u8]) {
-    Keyring::request("session")
-        .unwrap()
-        .add_key("cryptsetup", secret)
-        .unwrap();
-}

src/luks.rs

@@ -0,0 +1,82 @@
+use crate::error::*;
+
+use libcryptsetup_rs::{CryptActivateFlags, CryptDevice, CryptInit, EncryptionFormat, KeyslotInfo};
+use std::path::Path;
+
+fn load_device_handle<P: AsRef<Path>>(path: P) -> Fido2LuksResult<CryptDevice> {
+    let mut device = CryptInit::init(path.as_ref())?;
+    //TODO: determine luks version some way other way than just trying
+    let mut load = |format| device.context_handle().load::<()>(format, None).map(|_| ());
+    vec![EncryptionFormat::Luks2, EncryptionFormat::Luks1]
+        .into_iter()
+        .fold(None, |res, format| match res {
+            Some(Ok(())) => res,
+            Some(e) => Some(e.or_else(|_| load(format))),
+            None => Some(load(format)),
+        })
+        .unwrap()?;
+    Ok(device)
+}
+
+pub fn open_container<P: AsRef<Path>>(path: P, name: &str, secret: &[u8], slot_hint: Option<u32>) -> Fido2LuksResult<()> {
+    let mut device = load_device_handle(path)?;
+    device
+        .activate_handle()
+        .activate_by_passphrase(Some(name), slot_hint, secret, CryptActivateFlags::empty())
+        .map(|_slot| ())
+        .map_err(|_e| Fido2LuksError::WrongSecret)
+}
+
+pub fn add_key<P: AsRef<Path>>(
+    path: P,
+    secret: &[u8],
+    old_secret: &[u8],
+    iteration_time: Option<u64>,
+) -> Fido2LuksResult<u32> {
+    let mut device = load_device_handle(path)?;
+    if let Some(millis) = iteration_time {
+        device.settings_handle().set_iteration_time(millis)
+    }
+    let slot = device
+        .keyslot_handle(None)
+        .add_by_passphrase(old_secret, secret)?;
+    Ok(slot)
+}
+
+pub fn remove_keyslots<P: AsRef<Path>>(path: P, exclude: &[u32]) -> Fido2LuksResult<u32> {
+    let mut device = load_device_handle(path)?;
+    let mut handle;
+    let mut destroyed = 0;
+    //TODO: detect how many keyslots there are instead of trying within a given range
+    for slot in 0..1024 {
+        handle = device.keyslot_handle(Some(slot));
+        match handle.status()? {
+            KeyslotInfo::Inactive => continue,
+            KeyslotInfo::Active if !exclude.contains(&slot) => {
+                handle.destroy()?;
+                destroyed += 1;
+            }
+            _ => (),
+        }
+        if let KeyslotInfo::ActiveLast = handle.status()? {
+            break;
+        }
+    }
+    Ok(destroyed)
+}
+
+pub fn replace_key<P: AsRef<Path>>(
+    path: P,
+    secret: &[u8],
+    old_secret: &[u8],
+    iteration_time: Option<u64>,
+) -> Fido2LuksResult<u32> {
+    let mut device = load_device_handle(path)?;
+    // Set iteration time not sure wether this applies to luks2 as well
+    if let Some(millis) = iteration_time {
+        device.settings_handle().set_iteration_time(millis)
+    }
+    Ok(device
+        .keyslot_handle(None)
+        .change_by_passphrase(None, None, old_secret, secret)? as u32)
+}

src/main.rs

@@ -1,24 +1,11 @@
 #[macro_use]
 extern crate failure;
-extern crate serde_derive;
+extern crate ctap_hmac as ctap;
 use crate::cli::*;
 use crate::config::*;
 use crate::device::*;
 use crate::error::*;
-use crypto::digest::Digest;
+use std::io;
-use crypto::sha2::Sha256;
-use cryptsetup_rs as luks;
-
-use cryptsetup_rs::Luks1CryptDevice;
-use ctap;
-
-use luks::device::Error::CryptsetupError;
-
-use std::collections::HashMap;
-use std::env;
-
-use std::convert::TryInto;
-use std::io::{self, stdout, Write};
 use std::path::PathBuf;
 use std::process::exit;
 
@@ -26,195 +13,18 @@ mod cli;
 mod config;
 mod device;
 mod error;
-mod keystore;
+mod luks;
-
+mod util;
-fn open_container(device: &PathBuf, name: &str, secret: &[u8; 32]) -> Fido2LuksResult<()> {
-    let mut handle = luks::open(device.canonicalize()?)?.luks1()?;
-    let _slot = handle.activate(name, &secret[..])?;
-    Ok(())
-}
-
-fn assemble_secret(hmac_result: &[u8], salt: &[u8]) -> [u8; 32] {
-    let mut digest = Sha256::new();
-    digest.input(salt);
-    digest.input(hmac_result);
-    let mut secret = [0u8; 32];
-    digest.result(&mut secret);
-    secret
-}
-fn ask_str(q: &str) -> Fido2LuksResult<String> {
-    let stdin = io::stdin();
-    let mut s = String::new();
-    print!("{}", q);
-    io::stdout().flush()?;
-    stdin.read_line(&mut s)?;
-    Ok(s.trim().to_owned())
-}
-
-fn open(conf: &Config, secret: &[u8; 32]) -> Fido2LuksResult<()> {
-    dbg!(hex::encode(&secret));
-    match open_container(&conf.device, &conf.mapper_name, &secret) {
-        Err(Fido2LuksError::LuksError {
-            cause: CryptsetupError(errno),
-        }) if errno.0 == 1 => Err(Fido2LuksError::WrongSecret)?,
-        e => e?,
-    };
-    Ok(())
-}
-
-/*fn package_self() -> Fido2LuksResult<()> {
-    let conf = Config::load_default_location()?;
-    let binary_path: PathBuf = env::args().next().unwrap().into();
-    let mut me = File::open(binary_path)?;
-
-    me.seek(io::SeekFrom::End(("config".as_bytes().len() * -1) as i64 - 4))?;
-
-    let conf_len = me.read_u32()?;
-
-    let mut buf = vec![0u8; 512];
-
-    me.read(&mut buf[0..6])?;
-
-    if String::from_utf8((&buf[0..6]).iter().collect()).map(|s| &s == "config").unwrap_or(false) {
-
-    }
-
-    Ok(())
-}*/
 
 fn main() -> Fido2LuksResult<()> {
-    let args: Vec<_> = env::args().skip(1).collect();
+    match run_cli() {
-    fn config_env() -> Fido2LuksResult<EnvConfig> {
+        Err(e) => {
-        Ok(envy::prefixed("FIDO2LUKS_").from_env::<EnvConfig>()?)
+            #[cfg(debug_assertions)]
-    }
+            eprintln!("{:?}", e);
-    fn secret_from_env_config(conf: &EnvConfig) -> Fido2LuksResult<[u8; 32]> {
+            #[cfg(not(debug_assertions))]
-        let conf = config_env()?;
+            eprintln!("{}", e);
-        let salt =
+            exit(e.exit_code())
-            InputSalt::from(conf.salt.as_str()).obtain(&conf.password_helper.as_str().into())?;
-        Ok(assemble_secret(
-            &perform_challenge(&conf.credential_id, &salt)?,
-            &salt,
-        ))
-    }
-    match &args.iter().map(|s| s.as_str()).collect::<Vec<_>>()[..] {
-        ["print-secret"] => {
-            let conf = config_env()?;
-            io::stdout().write(hex::encode(&secret_from_env_config(&conf)?[..]).as_bytes())?;
-            Ok(io::stdout().flush()?)
-        }
-        ["open"] => {
-            let mut conf = config_env()?;
-            open_container(
-                &conf
-                    .device
-                    .as_ref()
-                    .expect("please specify FIDO2LUKS_DEVICE")
-                    .into(),
-                &conf
-                    .mapper_name
-                    .as_ref()
-                    .expect("please specify FIDO2LUKS_MAPPER_NAME"),
-                &secret_from_env_config(&conf)?,
-            )
-        }
-        ["open", device, mapper_name] => {
-            let mut conf = config_env()?;
-            conf.mapper_name = Some(mapper_name.to_string());
-            conf.device = Some(device.to_string());
-            open_container(
-                &conf
-                    .device
-                    .as_ref()
-                    .expect("please specify FIDO2LUKS_DEVICE")
-                    .into(),
-                &conf
-                    .mapper_name
-                    .as_ref()
-                    .expect("please specify FIDO2LUKS_MAPPER_NAME"),
-                &secret_from_env_config(&conf)?,
-            )
-        }
-        ["credential"] => {
-            let cred = make_credential_id()?;
-            println!("{}", hex::encode(&cred.id));
-            Ok(())
-        }
-        ["addkey", device] => {
-            let mut conf = config_env()?;
-            conf.device = conf.device.or(Some(device.to_string()));
-            let slot = add_key_to_luks(
-                conf.device.as_ref().unwrap().into(),
-                &secret_from_env_config(&conf)?,
-            )?;
-            println!("Added to key to device {}, slot: {}", device, slot);
-            Ok(())
-        }
-        _ => {
-            println!(
-                "Usage:\n
-            fido2luks open <device> [name]\n
-            fido2luks addkey <device>\n\n
-            Environment variables:\n
-            <FIDO2LUKS_CREDENTIAL_ID>\n
-            <FIDO2LUKS_SALT>\n
-            "
-            );
-            Ok(())
-        }
-    }
-}
-
-fn main_old() -> Fido2LuksResult<()> {
-    let args: Vec<_> = env::args().skip(1).collect(); //Ignore program name -> Vec
-    let env = env::vars().collect::<HashMap<_, _>>();
-    let secret = |conf: &Config| -> Fido2LuksResult<[u8; 32]> {
-        let salt = conf.input_salt.obtain(&conf.password_helper)?;
-
-        Ok(assemble_secret(
-            &perform_challenge(&conf.credential_id, &salt)?,
-            &salt,
-        ))
-    };
-    if args.is_empty() {
-        let conf = Config::load_default_location()?;
-        if env.contains_key("CRYPTTAB_NAME") {
-            //Indicates that this script is being run as keyscript
-            let mut out = stdout();
-            out.write(&secret(&conf)?)?;
-            Ok(out.flush()?)
-        } else {
-            io::stdout().write(&secret(&conf)?)?;
-            Ok(io::stdout().flush()?)
-        }
-    } else {
-        match args.first().map(|s| s.as_ref()).unwrap() {
-            //"addkey" => add_key_to_luks(&Config::load_default_location()?).map(|_| ()),
-            "setup" => setup(),
-            "open" if args.get(1).map(|a| &*a == "-e").unwrap_or(false) => {
-                let conf = envy::prefixed("FIDO2LUKS_")
-                    .from_env::<EnvConfig>()
-                    .expect("Missing env config values")
-                    .try_into()?;
-                open(&conf, &secret(&conf)?)
-            }
-            "open" => open(
-                &Config::load_default_location()?,
-                &secret(&Config::load_default_location()?)?,
-            ),
-            "connected" => match authenticator_connected()? {
-                false => {
-                    println!("no");
-                    exit(1)
-                }
-                _ => {
-                    println!("yes");
-                    exit(0)
-                }
-            },
-            _ => {
-                eprintln!("Usage: setup | addkey | connected");
-                Ok(())
-            } //"selfcontain" => package_self()
         }
+        _ => exit(0),
     }
 }

src/util.rs

@@ -0,0 +1,41 @@
+use crate::error::*;
+use ring::digest;
+use std::fs::File;
+use std::io::Read;
+use std::path::PathBuf;
+
+pub fn sha256(messages: &[&[u8]]) -> [u8; 32] {
+    let mut digest = digest::Context::new(&digest::SHA256);
+    for m in messages.iter() {
+        digest.update(m);
+    }
+    let mut secret = [0u8; 32];
+    secret.as_mut().copy_from_slice(digest.finish().as_ref());
+    secret
+}
+
+pub fn read_password(q: &str, verify: bool) -> Fido2LuksResult<String> {
+    match rpassword::read_password_from_tty(Some(&[q, ": "].join("")))? {
+        ref pass
+            if verify
+                && &rpassword::read_password_from_tty(Some(&[q, "(again): "].join(" ")))?
+                    != pass =>
+        {
+            Err(Fido2LuksError::AskPassError {
+                cause: AskPassError::Mismatch,
+            })
+        }
+        pass => Ok(pass),
+    }
+}
+
+pub fn read_password_hashed(q: &str, verify: bool) -> Fido2LuksResult<[u8; 32]> {
+    read_password(q, verify).map(|pass| sha256(&[pass.as_bytes()]))
+}
+
+pub fn read_keyfile<P: Into<PathBuf>>(path: P) -> Fido2LuksResult<Vec<u8>> {
+    let mut file = File::open(path.into())?;
+    let mut key = Vec::new();
+    file.read_to_end(&mut key)?;
+    Ok(key)
+}