RFC 4226 HOTP の主要なところを読んでみた。

  Step 1: Generate an HMAC-SHA-1 value
  Let HS = HMAC-SHA-1(K, C)  // HS is a 20-byte string

  Step 2: Generate a 4-byte string (Dynamic Truncation)
  Let Sbits = DT(HS)         // DT, defined below, returns a 31-bit string

  Step 3: Compute an HOTP value
  Let Snum = StToNum(Sbits)   // Convert Sbits to a number in 0...2^{31}-1
  Return D = Snum mod 10^Digit // D is a number in the range 0...10^{Digit}-1

DT(String) // String = String[0]...String[19]
  Let OffsetBits be the low-order 4 bits of String[19]
  Offset = StToNum(OffsetBits) // 0 <= Offset <= 15
  Let P = String[Offset]...String[Offset+3]
  Return the Last 31 bits of P

package main

import (
 "crypto/hmac"
 "crypto/sha1"
 "encoding/binary"
 "fmt"
 "math"
)

// HOTP calculates an OTP based on a shared key (K), counter (C), and desired number of digits.
func HOTP(K []byte, C uint64, digits int) int {
 // Step 1: Generate HMAC-SHA-1 value
 fmt.Println("Step 1: Generate HMAC-SHA-1 value")
 HS := hmacSha1(K, C)
 fmt.Printf("  HMAC-SHA-1 output (HS): %x\n", HS)

 // Step 2: Perform Dynamic Truncation
 fmt.Println("Step 2: Perform Dynamic Truncation")
 Sbits := dynamicTruncation(HS)
 fmt.Printf("  31-bit truncated value (Sbits): %d\n", Sbits)

 // Step 3: Compute the HOTP value
 fmt.Println("Step 3: Compute the HOTP value")
 Snum := int(Sbits)
 modulus := int(math.Pow10(digits))
 D := Snum % modulus
 fmt.Printf("  HOTP value (D): %0*d\n", digits, D)

 return D
}

// hmacSha1 generates the HMAC-SHA-1 value for a given key and counter
func hmacSha1(K []byte, C uint64) []byte {
 h := hmac.New(sha1.New, K)
 counterBytes := make([]byte, 8)
 binary.BigEndian.PutUint64(counterBytes, C) // Counter in BigEndian format
 h.Write(counterBytes)
 return h.Sum(nil) // Returns the 20-byte HMAC-SHA-1 output
}

// dynamicTruncation extracts 31 bits from the HMAC-SHA-1 result
func dynamicTruncation(HS []byte) uint32 {
 offset := HS[19] & 0x0F // Offset is the low 4 bits of the last byte
 fmt.Printf("  Offset (from last byte of HS): %d\n", offset)

 portion := HS[offset : offset+4] // Extract 4 bytes starting from offset
 fmt.Printf("  4-byte string extracted (portion): %x\n", portion)

 return binary.BigEndian.Uint32(portion) & 0x7FFFFFFF // Return last 31 bits
}

func main() {
 K := []byte("12345678901234567890") // Shared secret key
 C := uint64(1)                      // Counter value
 digits := 6                         // Desired OTP length

 otp := HOTP(K, C, digits)
 fmt.Printf("Final HOTP: %06d\n", otp) // Print the OTP value with zero padding
}

sequenceDiagram
    participant Client as クライアント
    participant Server as サーバー

    %% 初期設定
    Note over Client,Server: 初期設定<br>カウンター=0, シークレットキー共有

    %% 認証フロー開始
    Client->>Client: カウンターをインクリメント<br>カウンター=1
    Note over Client,Client: クライアントのカウンター=1
    Client->>Client: HOTP値を生成
    Client->>Server: HOTP値をサーバーに送信<br>(カウンター=1で生成)

    Server->>Server: 受信したHOTPと現在のカウンター(0)で検証
    alt 一致しない場合
        Note left of Server: ルックアヘッドウィンドウで再同期<br>カウンターを順次進めて検証<br>(例: 1～10)
        Server->>Server: カウンター=1で一致<br>認証成功
        Server->>Server: サーバーのカウンターを2に更新
        Note over Server,Server: サーバーのカウンター=2
    else 一致した場合
        Server->>Server: 認証成功
        Server->>Server: サーバーのカウンターを更新
        Note over Server,Server: サーバーのカウンター=2
    end

    Server->>Client: 認証成功メッセージ
    Note right of Client: クライアントとサーバーのカウンター<br>同期完了 (カウンター=2)

関連記事

• ネットワークスペシャリスト　IPSec
  
• ネットワークスペシャリスト　無線LANの認証方式
  
• ネットワークスペシャリスト　EAP
  
• ネットワークスペシャリスト　無線LANの暗号化方式
  
• ネットワークスペシャリスト　RADIUS
  
• ネットワークスペシャリスト　デジタル署名
  
• ネットワークスペシャリスト　ケロベロス(Kerberos)認証
  
• AWS VPCの基本概念とネットワーク接続
  
• RFC 6238 TOTP の主要なところを読んでみた。