cancel
Showing results for 
Search instead for 
Did you mean: 
Kai_Wilke
MVP
MVP

Problem this snippet solves:

Hi Folks,

the provided iRule contains a TMOS v11.1+ compatible fork of the already existing and very lovely Google Authenticator verification iRules here on CodeShare.

The iRule adds support for the full TOTP algorithm standard (see RFC 6238 as well as RFC 4226) by including a support for longer shared key sizes and the more complex HMAC-SHA256 as well as HMAC-SHA512 algorithms. In addition, the core functionality of the provided iRule is a complete revamp and contains lot of performance optimizations to reduce the required CPU cycles on TMOS v11.1+ platforms by a great degree.

The performance optimizations of this iRule are achieved by:

  1. Using the TMOS v11.1+ compatible [CRYPTO::sign -alg hmac-...] syntax to calculate HMAC values.
  2. Using a less complex and very minimalistic base32-to-binary [string map] conversation to decode the Google Authenticator keys.
  3. Using a serialized verification of multiple clock skews in a relative increasing/decreasing order to Unix epoch time.
  4. Using slightly optimized [expr { }] syntaxes.
  5. Avoiding unnecessary $variable usage.
  6. Avoiding calls into (rather slow) TCL procedures.

Performance comparison:

The performance data below was gathered by using a maximum allowed clock skew value of +/-5 minutes between clients and the F5, resulting in a calculation of either 1 verfication value (ideal case) or up to 21 verfication values (worst case) for a single token verification .

Test Name                                               | This iRule     | Previous iRule(s)| Savings 
Valid verification via Unix epoch time (ideal case)     | 191.078 cycles | 5.497.482 cycles | 96,6%
Valid verification via -2,5 min clock skew (median case)| 511.067 cycles | 5.504.262 cycles | 90,8%
Valid verification via -5 min clock skew (worst case)   | 816.676 cycles | 5.502.650 cycles | 85,2%
Invalid verification (always worst case)                | 849.217 cycles | 5.464.924 cycles | 84,5%

Note: The results of the "Previous iRule(s)" was gathered by using a striped down version (e.g. using fixed keys, tokens and clock values with disabled logging and HTTP responses) of Stanislas latest Google Authenticator HTTP API iRule, since it was (until today) the only published version that includes a support to handle token verification using multiple clock skews. The core functionality of Stanislas Google Authenticator HTTP API iRule is heavely based on the original Google Authenticator iRule published by George Watkins, but Stanislas already uses a slightly performance optimized syntax for certain [expr {}] syntaxes.

Cheers, Kai

Footnote: Special thanks goes to George Watkins for publishing the very first Google Authenticator iRule back in 2012. And also to Stanislas for publishing his Google Authenticator HTTP API iRule, which has introduced a handy HTTP API support for APM Policies and a very useful addition to handle clock skews.

How to use this snippet:

  1. Integrate the core functionality of this Google Authenticator Verification iRule in your own Google Authenticator solution.
  2. Tweak the $static::ga_key_size and $static::ga_hmac_mode settings as needed.
  3. Tweak the $static::allowed_clock_skew_units to set the maximum allowed clock skew units between your LTM and the end user devices.
  4. The variable $ga(key) is used to set the provisioned Google Authenticator shared user key.
  5. The variable $ga(token) is used to set the user provided Google Authenticator token.
  6. The variable $result stores the verification results.
  7. Enjoy!

Code :

when RULE_INIT {

##############################################################################################
# Configure the Google Authenticator key sizes and HMAC operation modes.
#
# Note: Google Authenticator uses a hardcoded 80 bit key length with HMAC-SHA1 verification. 
#       The underlying HOTP algorithm (see RFC 4226) and TOTP algorithm (RFC 6238) standards 
#       require at least 128 bit and even recommend a 160 bit key length. In addition, both 
#       RFC standards include HMAC-SHA256 and HMAC-SHA512 operation modes.
#       So if the Google Authenticator code is changed in the future to match the official
#       requirements or even recommendations, then you have to change the variables below.
#

set static::ga_key_size 80              ;# Shared key size in bits
set static::ga_hmac_mode "hmac-sha1"    ;# Options "hmac-sha1", "hmac-sha256" or "hmac-sha512" 


##############################################################################################
# Configure the allowed clock skew units (1 unit = +/-30 seconds in both directions)
#

set static::ga_allowed_clock_skew_units 10


##############################################################################################
# Initialize the Base32 alphabet to binary conversation (see RFC 4648)
#

set static::b32_to_binary [list \
A 00000 B 00001 C 00010 D 00011 \
E 00100 F 00101 G 00110 H 00111 \
I 01000 J 01001 K 01010 L 01011 \
M 01100 N 01101 O 01110 P 01111 \
Q 10000 R 10001 S 10010 T 10011 \
U 10100 V 10101 W 10110 X 10111 \
Y 11000 Z 11001 2 11010 3 11011 \
4 11100 5 11101 6 11110 7 11111 \
0 "" 1 "" = "" " " "" \
]
}
when HTTP_REQUEST {

##############################################################################################
# Defining the user provided token code and provisioned user key
#

set ga(token) "000000"
set ga(key) "ZVZG5UZU4D7MY4DH"

##############################################################################################
# Initialization of the Google Authentication iRule
#

# Map the Base32 encoded ga(key) to binary string representation and check length >= $static::ga_key_size

if { [string length [set ga(key) [string map -nocase $static::b32_to_binary $ga(key)]]] >= $static::ga_key_size } then {

# Convert the translated ga(key) binary string representation to binary

set ga(key) [binary format B$static::ga_key_size $ga(key)]

# Initialize ga(clock) timeframe based on Unix epoch time in seconds / 30

set ga(clock) [expr { [clock seconds] / 30 } ]

##############################################################################################
# Perform verification of the provided ga(token) for current time frame ga(clock)
#

# Calculate hex encoded HMAC checksum value for wide-int value of time frame ga(clock) using ga(key) as secret

binary scan [CRYPTO::sign -alg $static::ga_hmac_mode -key $ga(key) [binary format W* $ga(clock)]] H* ga(verify)

# Parse ga(offset) based on the last nibble (= 4 bits / 1 hex) of the ga(verify) HMAC checksum and multiply with 2 for byte to hex conversation

set ga(offset) [expr { "0x[string index $ga(verify) end]" * 2 } ]

# Parse (= 4 bytes / 8 hex) from ga(verify) starting at the ga(offset) value, then remove the most significant bit, perform the modulo 1000000 and format the result to a 6 digit number

set ga(verify) [format %06d [expr { ( "0x[string range $ga(verify) $ga(offset) [expr { $ga(offset) + 7 } ]]" & 0x7FFFFFFF ) % 1000000 } ]]

# Compare ga(verify) with user provided ga(token) value

if { $ga(verify) equals $ga(token) } then {

# The provided ga(token) is valid"
set result "valid"

} elseif { $static::ga_allowed_clock_skew_units > 0 } then {

##############################################################################################
# Perform verification of the provided ga(token) for additional clock skew units
#
# Note: The order is increasing/decreasing according to ga(clock) (aka. Unix epoch time +30sec, -30sec, +60sec, -60sec, etc.)
#

set result "invalid"

for { set x 1 } { $x <= $static::ga_allowed_clock_skew_units } { incr x } {

##############################################################################################
# Perform verification of the provided ga(token) for time frame ga(clock) + $x 
#

# Calculate hex encoded HMAC checksum value for wide-int value of time frame ga(clock) + x using ga(key) as secret

binary scan [CRYPTO::sign -alg $static::ga_hmac_mode -key $ga(key) [binary format W* [expr { $ga(clock) + $x }]]] H* ga(verify)

# Parse ga(offset) based on the last nibble (= 4 bits / 1 hex) of the ga(verify) HMAC checksum and multiply with 2 for byte to hex conversation

set ga(offset) [expr { "0x[string index $ga(verify) end]" * 2 } ]

# Parse (= 4 bytes / 8 hex) from ga(verify) starting at the ga(offset) value, then remove the most significant bit, perform the modulo 1000000 and format the result to a 6 digit number

set ga(verify) [format %06d [expr { ( "0x[string range $ga(verify) $ga(offset) [expr { $ga(offset) + 7 } ]]" & 0x7FFFFFFF ) % 1000000 } ]]

# Compare ga(verify) with user provided ga(token) value

if { $ga(verify) equals $ga(token) } then {

# The provided ga(token) is valid"
set result "valid"
break

}

##############################################################################################
# Perform verification of the provided ga(token) for time frame ga(clock) - $x 
#

# Calculate hex encoded HMAC checksum value for wide-int value of time frame ga(clock) - $x using ga(key) as secret

binary scan [CRYPTO::sign -alg $static::ga_hmac_mode -key $ga(key) [binary format W* [expr { $ga(clock) - $x }]]] H* ga(verify)

# Parse ga(offset) based on the last nibble (= 4 bits / 1 hex) of the ga(verify) HMAC checksum and multiply with 2 for byte to hex conversation

set ga(offset) [expr { "0x[string index $ga(verify) end]" * 2 } ]

# Parse (= 4 bytes / 8 hex) from ga(verify) starting at the ga(offset) value, then remove the most significant bit, perform the modulo 1000000 and format the result to a 6 digit number

set ga(verify) [format %06d [expr { ( "0x[string range $ga(verify) $ga(offset) [expr { $ga(offset) + 7 } ]]" & 0x7FFFFFFF ) % 1000000 } ]]

# Compare ga(verify) with user provided ga(token) value

if { $ga(verify) equals $ga(token) } then {

# The provided ga(token) is valid"
set result "valid"
break

}
}
} else {
# The provided ga(token) is invalid"
set result "invalid"
}
} else {
#The provided ga(key) is malformated
set result "error: malformated shared key"
}

unset -nocomplain ga

##############################################################################################
# Handle for token verification results
#

# log local0.debug "Verification Result: $result"
HTTP::respond 200 content "Verification Result: $result"
# return $result

}

Tested this on version:

12.0
Comments
Stanislas_Piro2
Cumulonimbus
Cumulonimbus

Hi Kai,

 

what do you think to use this loop instead of three times the same code: (~$i always return -(i+1)). codes are validated with values 0 -1 1 -2 2 ...

 

for {set i 0; set result 0} {$i < 20 && !($result)} {incr i} { foreach x "$i [expr {~$i}]" { Perform verification of the provided ga(token) for time frame ga(clock) $x Calculate hex encoded HMAC checksum value for wide-int value of time frame ga(clock) + x using ga(key) as secret binary scan [CRYPTO::sign -alg $static::ga_hmac_mode -key $ga(key) [binary format W* [expr { $ga(clock) + $x }]]] H* ga(verify) Parse ga(offset) based on the last nibble (= 4 bits / 1 hex) of the ga(verify) HMAC checksum and multiply with 2 for byte to hex conversation set ga(offset) [expr { "0x[string index $ga(verify) end]" * 2 } ] Parse (= 4 bytes / 8 hex) from ga(verify) starting at the ga(offset) value, then remove the most significant bit, perform the modulo 1000000 and format the result to a 6 digit number set ga(verify) [format %06d [expr { ( "0x[string range $ga(verify) $ga(offset) [expr { $ga(offset) + 7 } ]]" & 0x7FFFFFFF ) % 1000000 } ]] Compare ga(verify) with user provided ga(token) value if { $ga(verify) equals $ga(token) } then { The provided ga(token) is valid" set result 1 break } } }

I also replaced Valid / Invalid with 0 / 1

 

you can return status with [lindex {Invalid Valid} $result]

 

Kai_Wilke
MVP
MVP

Hi Stanislas,

 

Performance wise its better to use three tailordered code blocks. The problem of using cascaded for/foreach loops is, that you can't easily break further execution within the inner loop once a match is found. You have to use a variable to maintain the result and you need to check this variable on each subsequent iteration.

 

Usability wise its up to you. Personally I think that using three times a slightly modified code is slightly easier to understand than a cascaded for/foreach loop. But mileage may vary... 😉

 

Cheers, Kai

 

Stanislas_Piro2
Cumulonimbus
Cumulonimbus

Hi Kai,

 

You're right about the additional check... but I solved it by setting to variable $i the $static::ga_allowed_clock_skew_units value.

 

for {set i 0; set result 0} {$i < $static::ga_allowed_clock_skew_units} {incr i} { for each value $i, check value of $i and (-$i -1) . the following values are checked : $i = 0 --> 0, -1 $i = 1 --> 1, -2 $i = 2 --> 2, -3 foreach x "$i [expr {~$i}]" { Perform verification of the provided ga(token) for time frame ga(clock) $x Calculate hex encoded HMAC checksum value for wide-int value of time frame ga(clock) + x using ga(key) as secret binary scan [CRYPTO::sign -alg $static::ga_hmac_mode -key $ga(key) [binary format W* [expr { $ga(clock) + $x }]]] H* ga(verify) Parse ga(offset) based on the last nibble (= 4 bits / 1 hex) of the ga(verify) HMAC checksum and multiply with 2 for byte to hex conversation set ga(offset) [expr { "0x[string index $ga(verify) end]" * 2 } ] Parse (= 4 bytes / 8 hex) from ga(verify) starting at the ga(offset) value, then remove the most significant bit, perform the modulo 1000000 and format the result to a 6 digit number set ga(verify) [format %06d [expr { ( "0x[string range $ga(verify) $ga(offset) [expr { $ga(offset) + 7 } ]]" & 0x7FFFFFFF ) % 1000000 } ]] Compare ga(verify) with user provided ga(token) value if { $ga(verify) equals $ga(token) } then { The provided ga(token) is valid" set i $static::ga_allowed_clock_skew_units set result 1 break } } }

no more additional check. to solve understanding issue, I added a comment line 🙂

 

Stanislas_Piro2
Cumulonimbus
Cumulonimbus

another solution is to create the range of allowed clock in RULE_INIT

 

set static::ga_allowed_clock_skew_units 10 set static::ga_allowed_clock_range {0} for {set i 1} {$i < $static::ga_allowed_clock_skew_units} {incr i} { lappend static::ga_allowed_clock_range -$i lappend static::ga_allowed_clock_range $i }

then, use only one loop on this list:

 

foreach x $static::ga_allowed_clock_range { ...code... }
Kai_Wilke
MVP
MVP

Hi Stanislas,

 

sorry for being somewhat busy these days... 😞

 

The first iRule is still more complicated im my opinion and realy adds no benefit except to reduce the line count (which is somewhat unimportant). The second iRule is way better...

 

You could give it another try and see if you can even remove the last foreach loop to max it completly... 😉

 

Note: Got my first 1 star rating... this is lovely 😉

 

Cheers, Kai

 

Stanislas_Piro2
Cumulonimbus
Cumulonimbus

Hi Kai,

 

my goal is not to reduce line count but not have three times the same code. every time you want to edit this code, you must edit it three times...

 

we can't remove the last foreach loop because it is the one which allow to check all codes in defined range.

 

And this code deserve 5 stars as the code is well explained, is generic enough to be used by everyone and performance gain is high.

 

Version history
Last update:
‎06-Oct-2016 02:33
Updated by:
Contributors