Time-based one-time password algorithm: Difference between revisions

{{wikipedia}}

 

 

 

 

According to RFC 6238, the reference implementation is as follows:

 

 

=={{header|Caché ObjectScript}}==

 

Class Utils.Security [ Abstract ]

{

 

}

{{out|Example}}

<pre>

M4AKQBFI252H4BWO

</pre>

 

=={{header|Go}}==

A slightly [https://github.com/gwwfps/onetime/pull/1 fixed] version of a [https://github.com/gwwfps/onetime package by Zitao Zhang] (released under a [https://github.com/gwwfps/onetime/blob/master/LICENSE simplified BSD license]).

// implementing the HOTP and TOTP algorithms as specified by IETF RFC-4226

// and RFC-6238.

p[0] &= 0x7f

return p

{{out|Example use}}

(in a format that gets put into the [https://godoc.org/github.com/dchapes/onetime generated documentation])

 

import (

var code = otp.TOTP(secret)

fmt.Println(code)

 

=={{header|Racket}}==

This includes BASE32 encoding, token based authentication and other such stuff.

 

(require (only-in web-server/stuffers/hmac-sha1 HMAC-SHA1))

 

(base32-encode-bytes #"Super Secret Password Key 88!")

=> #"KN2XAZLSEBJWKY3SMV2CAUDBONZXO33SMQQEWZLZEA4DQII="

 

{{out}}

oh dear... fall back one time-frame...

742249 is *that* the same? #t</pre>

 

=={{header|Tcl}}==

This TOTP/HOTP module clocks in small by taking advantage of [https://core.tcl.tk/tcllib/doc/trunk/embedded/www/toc.html tcllib's] existing hashing and base32 modules.

 

# rfc6238 contains examples of hotp with 8-digit modulus and sha1/sha256/sha512 hmac

#

namespace eval ::totp {

package require sha1

oo::class create totp {

variable Secret

hotp $Secret $bytes

}

}

set hmac [sha1::hmac -bin $secret $bytes]

set ofs [string index $hmac end]

set chunk [string range $hmac $ofs $ofs+4]

binary scan $chunk I code

 

namespace export *

}

}

assert {{306281 553572 304383} eq [google 1400000000]}

 

=={{header|zkl}}==

Uses the MsgHash dll, which includes SHA-1, SHA-256 hashes and HMAC routines for SHA-* and MD5.

{{trans|Go}}

// OneTimePassword stores the configuration values relevant to HOTP/TOTP calculations.

fcn totp(secret){ hotp(secret, steps(Time.Clock.time())) }

fcn steps(now) { (now - baseTime)/timeStep } // elapsed time chunked

Note: MsgHash hashes return a string by default, they can also return the hash as bytes. Ditto the HMAC routines, it is the third parameter. So, to create a hmac that returns bytes, use (eg) MsgHash.extra.hmacSHA1.fp2(False), this creates a partial application (closure) of the hmac using SHA-1 fixing the third parameter as False.

{{out|Example uses}}

// Simple 6-digit HOTP code:

secret := "SOME_SECRET";

code := otp.totp(secret);

println(code) //-->eg 707355416

{{out|Example use}}

Showing how to sync with changes over time. A six digit OTP w/MD5 changing every 17 seconds. Latency can effect the result when totp is called at a time boundary, so a retry may be required.

secret,ts:= "SOME_SECRET",17;

otp := OneTimePassword(6,ts,Time.Clock.time(),MsgHash.extra.hmacMD5.fp2(False));

Atomic.sleep(10);

}

{{out}}

<pre>

{{out|HMAC code}}

The MsgHash HMAC routines are pretty simple (the hash code is C), included here for completeness:

fcn hmac(key,msg,hashFcn,asString){

kn:=key.len();

if(kn>blkSz) key=H(key).howza(0);

fcn hmacSHA1( key,msg,asString=True){ hmac(key,msg,MsgHash.SHA1, asString) }

fcn hmacSHA256(key,msg,asString=True){ hmac(key,msg,MsgHash.SHA256,asString) }