Better error handling and do not crash if an error occurres

Author: replydev

src/interface/table.rs

@@ -70,7 +70,10 @@ pub fn fill_table(table: &mut StatefulTable, elements: &[OTPElement]) {
             (i + 1).to_string(),
             element.issuer.to_owned(),
             label,
-            element.get_otp_code().unwrap(),
+            match element.get_otp_code() {
+                Ok(result) => result,
+                Err(error) => error.to_string(),
+            },
         ]);
     }
 }

src/otp/algorithms/hotp_maker.rs

@@ -13,16 +13,17 @@ use sha1::Sha1;
 use sha2::{Sha256, Sha512};
 
 use crate::otp::otp_algorithm::OTPAlgorithm;
+use crate::otp::otp_error::OtpError;
 
-pub fn hotp(secret: &str, algorithm: OTPAlgorithm, counter: u64) -> Result<u32, String> {
+pub fn hotp(secret: &str, algorithm: OTPAlgorithm, counter: u64) -> Result<u32, OtpError> {
     match algorithm {
         OTPAlgorithm::Sha256 => generate_hotp::<Sha256>(secret, counter),
         OTPAlgorithm::Sha512 => generate_hotp::<Sha512>(secret, counter),
         _ => generate_hotp::<Sha1>(secret, counter),
     }
 }
 
-fn generate_hotp<D>(secret: &str, counter: u64) -> Result<u32, String>
+fn generate_hotp<D>(secret: &str, counter: u64) -> Result<u32, OtpError>
 where
     D: CoreProxy,
     D::Core: HashMarker
@@ -37,21 +38,21 @@ where
     // decode the base32 secret
     let secret_decoded = match BASE32_NOPAD.decode(secret.as_bytes()) {
         Ok(result) => result,
-        Err(e) => return Err(format!("{e:?}")),
+        Err(e) => return Err(OtpError::SecretEncoding(e.kind, e.position)),
     };
 
     let hash = hotp_hash::<D>(&secret_decoded, counter);
 
     // calculate offset
     let offset: usize = match hash.last() {
         Some(result) => *result & 0xf,
-        None => return Err(String::from("Invalid digest")),
+        None => return Err(OtpError::InvalidOffset),
     } as usize;
 
     // calculate code
     let code_bytes: [u8; 4] = match hash[offset..offset + 4].try_into() {
         Ok(x) => x,
-        Err(_) => return Err(String::from("Invalid digest")),
+        Err(_) => return Err(OtpError::InvalidDigest),
     };
     Ok(u32::from_be_bytes(code_bytes) & 0x7fffffff)
 }

src/otp/algorithms/motp_maker.rs

@@ -1,8 +1,9 @@
 use std::time::SystemTime;
 
+use crate::otp::otp_error::OtpError;
 use md5::{Digest, Md5};
 
-pub fn motp(secret: &str, pin: &str, period: u64, digits: usize) -> Result<String, String> {
+pub fn motp(secret: &str, pin: &str, period: u64, digits: usize) -> Result<String, OtpError> {
     let seconds = SystemTime::now()
         .duration_since(SystemTime::UNIX_EPOCH)
         .unwrap()
@@ -17,7 +18,7 @@ fn get_motp_code(
     period: u64,
     digits: usize,
     seconds: u64,
-) -> Result<String, String> {
+) -> Result<String, OtpError> {
     // TODO MOTP Secrets are hex encoded, so do not use BASE32 at all
     let hex_secret = secret;
     let counter = seconds / period;

src/otp/algorithms/steam_otp_maker.rs

@@ -1,12 +1,13 @@
 // Ported from https://github.com/beemdevelopment/Aegis/blob/master/app/src/main/java/com/beemdevelopment/aegis/crypto/otp/OTP.java
 
 use crate::otp::otp_algorithm::OTPAlgorithm;
+use crate::otp::otp_error::OtpError;
 
 use super::totp_maker::totp;
 
 const STEAM_ALPHABET: &str = "23456789BCDFGHJKMNPQRTVWXY";
 
-pub fn steam(secret: &str, algorithm: OTPAlgorithm, digits: usize) -> Result<String, String> {
+pub fn steam(secret: &str, algorithm: OTPAlgorithm, digits: usize) -> Result<String, OtpError> {
     match totp(secret, algorithm) {
         Ok(v) => Ok(to_steam_string(v as usize, digits)),
         Err(e) => Err(e),

src/otp/algorithms/totp_maker.rs

@@ -1,10 +1,11 @@
 use std::time::SystemTime;
 
 use crate::otp::otp_algorithm::OTPAlgorithm;
+use crate::otp::otp_error::OtpError;
 
 use super::hotp_maker::hotp;
 
-pub fn totp(secret: &str, algorithm: OTPAlgorithm) -> Result<u32, String> {
+pub fn totp(secret: &str, algorithm: OTPAlgorithm) -> Result<u32, OtpError> {
     let time = SystemTime::now()
         .duration_since(SystemTime::UNIX_EPOCH)
         .unwrap()
@@ -18,7 +19,7 @@ fn generate_totp(
     time: u64,
     time_step: u64,
     skew: i64,
-) -> Result<u32, String> {
+) -> Result<u32, OtpError> {
     hotp(secret, algorithm, ((time as i64 + skew) as u64) / time_step)
 }
 

src/otp/algorithms/yandex_otp_maker.rs

@@ -16,6 +16,7 @@ use sha1::{Digest, Sha1};
 use sha2::{Sha256, Sha512};
 
 use crate::otp::otp_algorithm::OTPAlgorithm;
+use crate::otp::otp_error::OtpError;
 
 use super::hotp_maker::hotp_hash;
 
@@ -28,7 +29,7 @@ pub fn yandex(
     period: u64,
     digits: usize,
     algorithm: OTPAlgorithm,
-) -> Result<String, String> {
+) -> Result<String, OtpError> {
     let seconds = SystemTime::now()
         .duration_since(SystemTime::UNIX_EPOCH)
         .unwrap()
@@ -52,7 +53,7 @@ fn calculate_yandex_code<D>(
     period: u64,
     digits: usize,
     seconds: u64,
-) -> Result<String, String>
+) -> Result<String, OtpError>
 where
     D: CoreProxy,
     D::Core: HashMarker
@@ -66,7 +67,7 @@ where
 {
     let decoded_secret = match BASE32_NOPAD.decode(secret.as_bytes()) {
         Ok(r) => r,
-        Err(_) => return Err(String::from("Error during secret parsing")),
+        Err(e) => return Err(OtpError::SecretEncoding(e.kind, e.position)),
     };
 
     let parsed_secret = &decoded_secret.as_slice()[0..SECRET_LENGHT];
@@ -89,15 +90,15 @@ where
     // calculate offset
     let offset: usize = match period_hash.last() {
         Some(result) => *result & 0xf,
-        None => return Err(String::from("Invalid digest")),
+        None => return Err(OtpError::InvalidOffset),
     } as usize;
 
     period_hash[offset] &= 0x7f;
 
     // calculate code
     let code_bytes: [u8; 8] = match period_hash[offset..offset + 8].try_into() {
         Ok(x) => x,
-        Err(_) => return Err(String::from("Invalid digest")),
+        Err(_) => return Err(OtpError::InvalidDigest),
     };
 
     let code = u64::from_be_bytes(code_bytes);

src/otp/mod.rs

@@ -2,4 +2,5 @@ pub mod algorithms;
 pub mod migrations;
 pub mod otp_algorithm;
 pub mod otp_element;
+mod otp_error;
 pub mod otp_type;

src/otp/otp_element.rs

@@ -1,5 +1,6 @@
 use std::{fs::File, io::Write, path::PathBuf, vec};
 
+use crate::otp::otp_error::OtpError;
 use crate::{
     crypto::cryptography::{argon_derive_key, encrypt_string_with_key, gen_salt},
     utils,
@@ -252,7 +253,7 @@ impl OTPElement {
             .build()
     }
 
-    pub fn get_otp_code(&self) -> Result<String, String> {
+    pub fn get_otp_code(&self) -> Result<String, OtpError> {
         match self.type_ {
             OTPType::Totp => {
                 let code = totp(&self.secret, self.algorithm)?;
@@ -265,9 +266,7 @@ impl OTPElement {
 
                     Ok(self.format_code(code))
                 }
-                None => Err(String::from(
-                    "The element is an HOTP code but there is no counter value.",
-                )),
+                None => Err(OtpError::MissingCounter),
             },
             OTPType::Steam => steam(&self.secret, self.algorithm, self.digits as usize),
             OTPType::Yandex => match &self.pin {
@@ -278,9 +277,7 @@ impl OTPElement {
                     self.digits as usize,
                     self.algorithm,
                 ),
-                None => Err(String::from(
-                    "This element is a Yandex code but there is not pin value",
-                )),
+                None => Err(OtpError::MissingPin),
             },
             OTPType::Motp => match &self.pin {
                 Some(pin) => motp(
@@ -289,9 +286,7 @@ impl OTPElement {
                     self.period,
                     self.digits as usize,
                 ),
-                None => Err(String::from(
-                    "This element is an MOTP code but the is not pin value",
-                )),
+                None => Err(OtpError::MissingPin),
             },
         }
     }

src/otp/otp_error.rs

@@ -0,0 +1,27 @@
+use data_encoding::DecodeKind;
+use std::fmt::{Display, Formatter};
+
+#[derive(Debug, PartialEq)]
+pub enum OtpError {
+    SecretEncoding(DecodeKind, usize), // Secret encoding error, of given kind at give position
+    MissingPin,                        // Missing Pin for Yandex / MOTP Codes
+    MissingCounter,                    // Missing counter for HOTP codes
+    InvalidOffset,                     // Invalid offset
+    InvalidDigest,                     // Invalid digest
+}
+
+impl Display for OtpError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            OtpError::SecretEncoding(decode_kind, position) => {
+                f.write_str(format!("Decode error {decode_kind} at {position}").as_str())
+            }
+            OtpError::MissingPin => f.write_str("Missing pin value"),
+            OtpError::MissingCounter => f.write_str("Missing counter value"),
+            OtpError::InvalidDigest => f.write_str("Invalid digest"),
+            OtpError::InvalidOffset => f.write_str("Invalid offset"),
+        }
+    }
+}
+
+impl std::error::Error for OtpError {}