Enum nitrokey::DeviceWrapper

pub enum DeviceWrapper<'a> {
    Storage(Storage<'a>),
    Pro(Pro<'a>),
}

A wrapper for a Nitrokey device of unknown type.

Use the connect method to obtain a wrapped instance. The wrapper implements all traits that are shared between all Nitrokey devices so that the shared functionality can be used without knowing the type of the underlying device. If you want to use functionality that is not available for all devices, you have to extract the device.

Examples

Authentication with error handling:

use nitrokey::{Authenticate, DeviceWrapper, User};

fn perform_user_task<'a>(device: &User<'a, DeviceWrapper<'a>>) {}
fn perform_other_task(device: &DeviceWrapper) {}

let mut manager = nitrokey::take()?;
let device = manager.connect()?;
let device = match device.authenticate_user("123456") {
    Ok(user) => {
        perform_user_task(&user);
        user.device()
    },
    Err((device, err)) => {
        eprintln!("Could not authenticate as user: {}", err);
        device
    },
};
perform_other_task(&device);

Device-specific commands:

use nitrokey::{DeviceWrapper, Storage};

fn perform_common_task(device: &DeviceWrapper) {}
fn perform_storage_task(device: &Storage) {}

let mut manager = nitrokey::take()?;
let device = manager.connect()?;
perform_common_task(&device);
match device {
    DeviceWrapper::Storage(storage) => perform_storage_task(&storage),
    _ => (),
};

Variants

Storage(Storage<'a>)

A Nitrokey Storage device.

Pro(Pro<'a>)

A Nitrokey Pro device.

Trait Implementations

impl<'a> Authenticate<'a> for DeviceWrapper<'a>

fn authenticate_user(
    self,
    password: &str
) -> Result<User<'a, Self>, (Self, Error)>

Performs user authentication. This method consumes the device. If successful, an authenticated device is returned. Otherwise, the current unauthenticated device and the error are returned.

fn authenticate_admin(
    self,
    password: &str
) -> Result<Admin<'a, Self>, (Self, Error)>

Performs admin authentication. This method consumes the device. If successful, an authenticated device is returned. Otherwise, the current unauthenticated device and the error are returned.

impl<'a> Debug for DeviceWrapper<'a>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a> Device<'a> for DeviceWrapper<'a>

fn into_manager(self) -> &'a mut Manager

Returns the [Manager][] instance that has been used to connect to this device.

fn get_model(&self) -> Model

Returns the model of the connected Nitrokey device.

fn get_status(&self) -> Result<Status, Error>

Returns the status of the Nitrokey device.

fn get_serial_number(&self) -> Result<String, Error>

Returns the serial number of the Nitrokey device. The serial number is the string representation of a hex number.

fn get_user_retry_count(&self) -> Result<u8, Error>

Returns the number of remaining authentication attempts for the user. The total number of available attempts is three.

fn get_admin_retry_count(&self) -> Result<u8, Error>

Returns the number of remaining authentication attempts for the admin. The total number of available attempts is three.

fn get_firmware_version(&self) -> Result<FirmwareVersion, Error>

Returns the firmware version.

fn get_config(&self) -> Result<Config, Error>

Returns the current configuration of the Nitrokey device.

fn change_admin_pin(&mut self, current: &str, new: &str) -> Result<(), Error>

Changes the administrator PIN.

fn change_user_pin(&mut self, current: &str, new: &str) -> Result<(), Error>

Changes the user PIN.

fn unlock_user_pin(
    &mut self,
    admin_pin: &str,
    user_pin: &str
) -> Result<(), Error>

Unlocks the user PIN after three failed login attempts and sets it to the given value.

fn lock(&mut self) -> Result<(), Error>

Locks the Nitrokey device.

fn factory_reset(&mut self, admin_pin: &str) -> Result<(), Error>

Performs a factory reset on the Nitrokey device.

fn build_aes_key(&mut self, admin_pin: &str) -> Result<(), Error>

Builds a new AES key on the Nitrokey.

impl<'a> From<Pro<'a>> for DeviceWrapper<'a>

fn from(device: Pro<'a>) -> Self

Performs the conversion.

impl<'a> From<Storage<'a>> for DeviceWrapper<'a>

fn from(device: Storage<'a>) -> Self

Performs the conversion.

impl<'a> GenerateOtp for DeviceWrapper<'a>

fn get_hotp_slot_name(&self, slot: u8) -> Result<String, Error>

Returns the name of the given HOTP slot.

fn get_totp_slot_name(&self, slot: u8) -> Result<String, Error>

Returns the name of the given TOTP slot.

fn get_hotp_code(&mut self, slot: u8) -> Result<String, Error>

Generates an HOTP code on the given slot. This operation may require user authorization, depending on the device configuration (see [get_config][]).

fn get_totp_code(&self, slot: u8) -> Result<String, Error>

Generates a TOTP code on the given slot. This operation may require user authorization, depending on the device configuration (see [get_config][]).

fn set_time(&mut self, time: u64, force: bool) -> Result<(), Error>

Sets the time on the Nitrokey.

impl<'a> GetPasswordSafe<'a> for DeviceWrapper<'a>

fn get_password_safe(
    &mut self,
    user_pin: &str
) -> Result<PasswordSafe<'_, 'a>, Error>

Enables and returns the password safe.