动态密码TOTP

package gtotp

import (
	"crypto/hmac"
	"crypto/sha512"
	"fmt"
	"hash"
	"math"
	"time"
)

type Totp struct {
	secret string           // the K, also the shared secret
	cfg    TotpAlgorithmCfg // totp algorithm config parameters
	hasher *Hasher          // Hmac hash function
}

type TotpAlgorithmCfg struct {
	rtnDigitSize int // the return digit value length
	t0           int // the T0, default is 0
	timeStep     int // the X, default is 30
}

type Hasher struct {
	HashName string           // hash digit name
	Digest   func() hash.Hash // hash function, default is sha512
}

// NewDefaultTotp return Totp reference using default config parameters.
func NewDefaultTotp(sharedSecret string) *Totp {
	return &Totp{
		secret: sharedSecret,
		cfg: TotpAlgorithmCfg{
			rtnDigitSize: 10,
			t0:           0,
			timeStep:     30,
		},
		hasher: &Hasher{
			HashName: "sha512",
			Digest:   sha512.New,
		},
	}
}

// Now return the digit value by current timestamp.
func (t *Totp) Now() string {
	return t.At(int(time.Now().Unix()))
}

// At return the gigit value with the timestamp parameter.
func (t *Totp) At(timestamp int) string {
	currentSteps := t.steps(timestamp)
	byteSecret := []byte(t.secret)
	secretHash := hmac.New(t.hasher.Digest, byteSecret)
	bSteps := Itob(currentSteps)
	secretHash.Write(bSteps)
	hmacHash := secretHash.Sum(nil)

	offset := int(hmacHash[len(hmacHash)-1] & 0xf)

	code := ((int(hmacHash[offset]) & 0x7f) << 24) |
		((int(hmacHash[offset+1] & 0xff)) << 16) |
		((int(hmacHash[offset+2] & 0xff)) << 8) |
		(int(hmacHash[offset+3]) & 0xff)

	code = code % int(math.Pow10(t.cfg.rtnDigitSize))
	return fmt.Sprintf(fmt.Sprintf("%%0%dd", t.cfg.rtnDigitSize), code)
}

// calculate the steps of timestamp.
func (t *Totp) steps(timestamp int) int {
	return int((timestamp - t.cfg.t0) / t.cfg.timeStep)
}

// integer to byte array
func Itob(integer int) []byte {
	byteArr := make([]byte, 8)
	for i := 7; i >= 0; i-- {
		byteArr[i] = byte(integer & 0xff)
		integer = integer >> 8
	}
	return byteArr
}

package gtotp

import (
	"github.com/magiconair/properties/assert"
	"testing"
)

func TestTotp_At(t *testing.T) {
	totp := NewDefaultTotp("ninja@example.comHENNGECHALLENGE003")
	timestamp := 1594352095
	digitVal := totp.At(timestamp)
	assert.Equal(t, "0517636551", digitVal)
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.lang.reflect.UndeclaredThrowableException;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.security.GeneralSecurityException;

/**
 * @author zhaoyang on 2020-07-10.
 */
public class Totp {

    private static final long[] DIGITS_POWER = {
        1L,10L,100L,1000L,10000L,100000L,1000000L,10000000L,100000000L,1000000000L,10000000000L
    };

    private long timeStep = 30L;
    private long t0 = 0L;
    private long rtnDigitSize = 10L;
    private String hmacShaName = "HmacSHA512";

    public Totp() {
        this(30L, 0L, 10L, "HmacSHA512");
    }

    public Totp(long timeStep, long t0, long rtnDigitSize, String hmacShaName) {
        this.timeStep = timeStep;
        this.t0 = t0;
        this.rtnDigitSize = rtnDigitSize;
        this.hmacShaName = hmacShaName;
    }

    public String genTotp(String secret, long time){
        StringBuilder result = null;

        long steps = (time - this.t0) / this.timeStep;

        byte[] secretBytes = secret.getBytes(StandardCharsets.UTF_8);
        byte[] hash = getHmacSha(this.hmacShaName, secretBytes, longToBytes(steps));

        // put selected bytes into result int
        int offset = hash[hash.length - 1] & 0xf;

        long code =
            ((hash[offset] & 0x7f) << 24) |
                ((hash[offset + 1] & 0xff) << 16) |
                ((hash[offset + 2] & 0xff) << 8) |
                (hash[offset + 3] & 0xff);

        code = (code % DIGITS_POWER[(int) this.rtnDigitSize]);

        result = new StringBuilder(Long.toString(code));

        while (result.length() < this.rtnDigitSize) {
            result.insert(0, "0");
        }
        return result.toString();
    }

    public static byte[] longToBytes(long x) {
        ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
        buffer.putLong(x);
        return buffer.array();
    }

    private static byte[] getHmacSha(String crypto, byte[] secretBytes, byte[] msgBytes){
        try {
            Mac hmac = Mac.getInstance(crypto);
            SecretKeySpec macKey =
                new SecretKeySpec(secretBytes, "RAW");
            hmac.init(macKey);
            return hmac.doFinal(msgBytes);
        } catch (GeneralSecurityException gse) {
            throw new UndeclaredThrowableException(gse);
        }
    }

    public static void main(String[] args) {
        Totp totp = new Totp();
        System.out.println(totp.genTotp("ninja@example.comHENNGECHALLENGE003", 1594352095));
    }
}