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

{{wikipedia}}

 

 

 

 

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

 

 

=={{header|C sharp|C#}}==

using System.Security.Cryptography;

 

}

}

 

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

 

Class Utils.Security [ Abstract ]

{

 

}

{{out|Example}}

<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|Julia}}==

using SHA

 

sleep(15)

end

<pre>

656601

514592

514592

</pre>

 

=={{header|PicoLisp}}==

Using the <tt>sha1</tt> function defined at ''[[SHA-1#PicoLisp]]'':

 

(de hmac ("Fun" Msg Key)

(test

(cdr L)

 

=={{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}}

(formerly Perl 6)

This is a minimal attempt that covers only the "Time-based" part of the requirement.

# https://github.com/retupmoca/P6-Digest-HMAC

 

say totp $message, DateTime.new(now);

}

{{out}}

<pre>Deterministic output at 2039-01-01T00:00:00Z with fixed checks,

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){

blkSz,H,Hx := 64,hashFcn.fp1(1,Data()), (asString and hashFcn or H);

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

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