Enum Algorithm

pub enum Algorithm {
    SHA1,
    SHA256,
    SHA512,
}

Enumeration of supported cryptographic hash algorithms for use with HMAC.

This enum allows users to choose between SHA-1, SHA-256, and SHA-512 as required by OTP generation specifications.

The default value is SHA1, which is the original algorithm used in HOTP.

Variants

SHA1

SHA256

SHA512

Implementations

impl Algorithm

pub fn hash_hex(&self, data: &[u8]) -> String

Hashes binary input data using the selected algorithm, returning the result as a hex string.

Arguments

• data - The input string to hash

Returns

A hexadecimal representation of the hash output.

Example

use otp::Algorithm;

let sha1_hash = Algorithm::SHA1.hash_hex(b"");
assert_eq!(sha1_hash.len(), 40); // 160-bit = 20 bytes = 40 hex chars

let sha256_hash = Algorithm::SHA256.hash_hex(b"");
assert_eq!(sha256_hash.len(), 64); // 256-bit = 32 bytes = 64 hex chars

let sha512_hash = Algorithm::SHA512.hash_hex(b"");
assert_eq!(sha512_hash.len(), 128); // 512-bit = 64 bytes = 128 hex chars

pub fn hash_bytes(&self, data: &[u8]) -> Vec<u8>

Hashes binary input data using the selected algorithm, returning raw bytes.

Arguments

• data - A byte slice of input data to hash

Returns

A Vec<u8> containing the hash output.

Example

use otp::Algorithm;

let sha1_hash = Algorithm::SHA1.hash_bytes(b"");
assert_eq!(sha1_hash.len(), 20); // 160-bit = 20 bytes

let sha256_hash = Algorithm::SHA256.hash_bytes(b"");
assert_eq!(sha256_hash.len(), 32); // 256-bit = 32 bytes

let sha512_hash = Algorithm::SHA512.hash_bytes(b"");
assert_eq!(sha512_hash.len(), 64); // 512-bit = 64 bytes

Trait Implementations

impl Clone for Algorithm

fn clone(&self) -> Algorithm

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for Algorithm

fn default() -> Algorithm

Returns the “default value” for a type.

impl Display for Algorithm

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

Formats the value using the given formatter.

impl PartialEq for Algorithm

fn eq(&self, other: &Algorithm) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Algorithm

impl Eq for Algorithm

impl StructuralPartialEq for Algorithm