Botan::HOTP Class Reference

#include <otp.h>

Public Member Functions
uint32_t	generate_hotp (uint64_t counter)
	HOTP (const SymmetricKey &key, std::string_view hash_algo="SHA-1", size_t digits=6)
	HOTP (const uint8_t key[], size_t key_len, std::string_view hash_algo="SHA-1", size_t digits=6)
std::pair< bool, uint64_t >	verify_hotp (uint32_t otp, uint64_t starting_counter, size_t resync_range=0)

Detailed Description

HOTP one time passwords (RFC 4226)

Definition at line 19 of file otp.h.

Constructor & Destructor Documentation

HOTP() [1/2]

Botan::HOTP::HOTP ( const SymmetricKey & key, std::string_view hash_algo = "SHA-1", size_t digits = 6 )

inline

Parameters

key	the secret key shared between client and server
hash_algo	the hash algorithm to use, should be SHA-1 or SHA-256
digits	the number of digits in the OTP (must be 6, 7, or 8)

Definition at line 26 of file otp.h.

                                                                                           :
            HOTP(key.begin(), key.size(), hash_algo, digits) {}

HOTP() [2/2]

Botan::HOTP::HOTP	(	const uint8_t	key[],
		size_t	key_len,
		std::string_view	hash_algo = "SHA-1",
		size_t	digits = 6 )

Parameters

key	the secret key shared between client and server
key_len	length of key param
hash_algo	the hash algorithm to use, should be SHA-1 or SHA-256
digits	the number of digits in the OTP (must be 6, 7, or 8)

Definition at line 15 of file hotp.cpp.

                                                                                       {
   BOTAN_ARG_CHECK(digits == 6 || digits == 7 || digits == 8, "Invalid HOTP digits");
 
   if(digits == 6) {
      m_digit_mod = 1000000;
   } else if(digits == 7) {
      m_digit_mod = 10000000;
   } else if(digits == 8) {
      m_digit_mod = 100000000;
   }
 
   /*
   RFC 4228 only supports SHA-1 but TOTP allows SHA-256 and SHA-512
   and some HOTP libs support one or both as extensions
   */
   if(hash_algo == "SHA-1") {
      m_mac = MessageAuthenticationCode::create_or_throw("HMAC(SHA-1)");
   } else if(hash_algo == "SHA-256") {
      m_mac = MessageAuthenticationCode::create_or_throw("HMAC(SHA-256)");
   } else if(hash_algo == "SHA-512") {
      m_mac = MessageAuthenticationCode::create_or_throw("HMAC(SHA-512)");
   } else {
      throw Invalid_Argument("Unsupported HOTP hash function");
   }
 
   m_mac->set_key(key, key_len);
}

References BOTAN_ARG_CHECK, and Botan::MessageAuthenticationCode::create_or_throw().

Member Function Documentation

generate_hotp()

uint32_t Botan::HOTP::generate_hotp

(

uint64_t

counter

)

Generate the HOTP for a particular counter value

Warning

if the counter value is repeated the OTP ceases to be one-time

Definition at line 43 of file hotp.cpp.

                                             {
   m_mac->update_be(counter);
   const secure_vector<uint8_t> mac = m_mac->final();
 
   const size_t offset = mac[mac.size() - 1] & 0x0F;
   const uint32_t code = load_be<uint32_t>(mac.data() + offset, 0) & 0x7FFFFFFF;
   return code % m_digit_mod;
}

References Botan::load_be().

Referenced by Botan::TOTP::generate_totp(), verify_hotp(), and Botan::TOTP::verify_totp().

verify_hotp()

std::pair< bool, uint64_t > Botan::HOTP::verify_hotp	(	uint32_t	otp,
		uint64_t	starting_counter,
		size_t	resync_range = 0 )

Check an OTP value using a starting counter and a resync range

Parameters

otp	the client provided OTP
starting_counter	the server's guess as to the current counter state
resync_range	if 0 then only HOTP(starting_counter) is accepted If larger than 0, up to resync_range values after HOTP are also checked.

Returns

(valid,next_counter). If the OTP does not validate, always returns (false,starting_counter). Otherwise returns (true,next_counter) where next_counter is at most starting_counter + resync_range + 1

Definition at line 52 of file hotp.cpp.

                                                                                                      {
   for(size_t i = 0; i <= resync_range; ++i) {
      if(generate_hotp(starting_counter + i) == otp) {
         return std::make_pair(true, starting_counter + i + 1);
      }
   }
   return std::make_pair(false, starting_counter);
}

References generate_hotp().

---

The documentation for this class was generated from the following files:

• src/lib/misc/hotp/otp.h
• src/lib/misc/hotp/hotp.cpp