SPLATS Developers Site

import hmac
import hashlib
import time
import base64


def generate_totp(totp_seed_b32: str, timestep: int) -> str:
    """
    TOTP（Time-based One-Time Password）を生成
    RFC 6238準拠の実装
    """
    # Base32デコードして秘密鍵を取得
    totp_seed = base64.b32decode(totp_seed_b32)

    # 現在時刻からカウンター値を計算
    current_step = int(time.time()) // timestep
    counter = current_step.to_bytes(8, byteorder='big')

    # HMAC-SHA1でハッシュを計算
    hmac_result = hmac.new(totp_seed, counter, hashlib.sha1).digest()

    # Dynamic Truncation: 最後のバイトの下位4ビットをオフセットとして使用
    offset = hmac_result[19] & 0xf

    # オフセット位置から4バイトを取得し31ビット整数を構成
    otp = (
        (hmac_result[offset] & 0x7f) << 24
        | (hmac_result[offset + 1] & 0xff) << 16
        | (hmac_result[offset + 2] & 0xff) << 8
        | (hmac_result[offset + 3] & 0xff)
    ) % 1000000

    # 6桁の文字列として返す
    return str(otp).zfill(6)


if __name__ == '__main__':
    # Base32エンコードされたシード（メンバー取得APIで得られるtotp_seed）
    totp_seed_b32 = 'JH4MV7R7FV55TVB43FKSE5GNV2JRXXAL'
    # タイムステップ（メンバー取得APIで得られるtimestep）
    timestep = 30
    totp_code = generate_totp(totp_seed_b32, timestep)
    print(totp_code)

import { createHmac } from 'crypto';

/**
 * Base32文字列をUint8Arrayにデコードする
 */
function base32Decode(input) {
    const BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
    const normalizedInput = input.toUpperCase().replace(/=/g, "");

    const fiveBitValues = [];
    for (const char of normalizedInput) {
        const alphabetIndex = BASE32_ALPHABET.indexOf(char);
        if (alphabetIndex === -1) {
            throw new Error(`Invalid Base32 character: '${char}'`);
        }
        fiveBitValues.push(alphabetIndex);
    }

    const decodedBytes = [];
    let accumulator = 0;
    let bitsInAccumulator = 0;

    for (const fiveBits of fiveBitValues) {
        accumulator = (accumulator << 5) | fiveBits;
        bitsInAccumulator += 5;

        while (bitsInAccumulator >= 8) {
            const byte = (accumulator >> (bitsInAccumulator - 8)) & 0xFF;
            decodedBytes.push(byte);
            bitsInAccumulator -= 8;
        }
    }

    return new Uint8Array(decodedBytes);
}

/**
 * TOTP（Time-based One-Time Password）を生成
 * RFC 6238準拠の実装
 */
function generateTotp(totpSeedB32, timestep) {
    // Base32デコードして秘密鍵を取得
    const totpSeed = base32Decode(totpSeedB32);

    // 現在時刻からカウンター値を計算
    const currentStep = Math.floor(Date.now() / 1000 / timestep);
    const counterBytes = new Uint8Array(8);
    const view = new DataView(counterBytes.buffer);
    view.setBigUint64(0, BigInt(currentStep), false);  // false = ビッグエンディアン

    // HMAC-SHA1でハッシュを計算
    const hmacResult = new Uint8Array(createHmac('sha1', totpSeed).update(counterBytes).digest());

    // Dynamic Truncation: 最後のバイトの下位4ビットをオフセットとして使用
    const offset = hmacResult[19] & 0xf;

    // オフセット位置から4バイトを取得し31ビット整数を構成
    const otp = (
        (hmacResult[offset] & 0x7f) << 24
        | (hmacResult[offset + 1] & 0xff) << 16
        | (hmacResult[offset + 2] & 0xff) << 8
        | (hmacResult[offset + 3] & 0xff)
    ) % 1000000;

    // 6桁の文字列として返す
    return otp.toString().padStart(6, '0');
}

function main() {
    // Base32エンコードされたシード（メンバー取得APIで得られるtotp_seed）
    const totpSeedB32 = 'JH4MV7R7FV55TVB43FKSE5GNV2JRXXAL';
    // タイムステップ（メンバー取得APIで得られるtimestep）
    const timestep = 30;
    const totpCode = generateTotp(totpSeedB32, timestep);
    console.log(totpCode);
}

main();

package main

import (
	"crypto/hmac"
	"crypto/sha1"
	"encoding/base32"
	"encoding/binary"
	"fmt"
	"time"
)

// generateTotp はTOTP（Time-based One-Time Password）を生成
// RFC 6238準拠の実装
func generateTotp(totpSeedB32 string, timestep int) (string, error) {
	// Base32デコードして秘密鍵を取得
	totpSeed, err := base32.StdEncoding.DecodeString(totpSeedB32)
	if err != nil {
		return "", err
	}

	// 現在時刻からカウンター値を計算
	currentStep := time.Now().Unix() / int64(timestep)
	counter := make([]byte, 8)
	binary.BigEndian.PutUint64(counter, uint64(currentStep))

	// HMAC-SHA1でハッシュを計算
	h := hmac.New(sha1.New, totpSeed)
	h.Write(counter)
	hmacResult := h.Sum(nil)

	// Dynamic Truncation: 最後のバイトの下位4ビットをオフセットとして使用
	offset := hmacResult[19] & 0xf

	// オフセット位置から4バイトを取得し31ビット整数を構成
	otp := (int(hmacResult[offset]&0x7f) << 24 |
		int(hmacResult[offset+1]&0xff) << 16 |
		int(hmacResult[offset+2]&0xff) << 8 |
		int(hmacResult[offset+3]&0xff)) % 1000000

	// 6桁の文字列として返す
	return fmt.Sprintf("%06d", otp), nil
}

func main() {
	// Base32エンコードされたシード（メンバー取得APIで得られるtotp_seed）
	totpSeedB32 := "JH4MV7R7FV55TVB43FKSE5GNV2JRXXAL"
	// タイムステップ（メンバー取得APIで得られるtimestep）
	timestep := 30
	totpCode, err := generateTotp(totpSeedB32, timestep)
	if err != nil {
		panic(err)
	}
	fmt.Println(totpCode)
}

import time


def get_totp_expiration_in_seconds(timestep: int):
    """
    TOTPの現在のタイムステップの残り秒数を計算する
    """
    current_unix_time = int(time.time())

    # 現在の時間窓内での経過秒数を計算
    elapsed_seconds_in_current_window = current_unix_time % timestep

    # 残り秒数 = タイムステップ - 経過秒数
    expiration_in_seconds = timestep - elapsed_seconds_in_current_window

    return expiration_in_seconds


if __name__ == '__main__':
    # タイムステップ（メンバー取得APIで得られるtimestep）
    timestep = 30

    # 現在のタイムステップの残り秒数を出力
    print(get_totp_expiration_in_seconds(timestep))

/**
 * TOTPの現在のタイムステップの残り秒数を計算する
 */
function getTotpExpirationInSeconds(timestep) {
    const currentUnixTime = Math.floor(Date.now() / 1000);

    // 現在の時間窓内での経過秒数を計算
    const elapsedSecondsInCurrentWindow = currentUnixTime % timestep;

    // 残り秒数 = タイムステップ - 経過秒数
    const expirationInSeconds = timestep - elapsedSecondsInCurrentWindow;

    return expirationInSeconds;
}

// 使用例
function main() {
    // タイムステップ（メンバー取得APIで得られるtimestep）
    const timestep = 30;

    // 現在のタイムステップの残り秒数を出力
    console.log(getTotpExpirationInSeconds(timestep));
}

// 実行
main();

package main

import (
	"fmt"
	"time"
)

// TOTPの現在のタイムステップの残り秒数を計算する
func getTotpExpirationInSeconds(timestep int64) int64 {
	currentUnixTime := time.Now().Unix()

	// 現在の時間窓内での経過秒数を計算
	elapsedSecondsInCurrentWindow := currentUnixTime % timestep

	// 残り秒数 = タイムステップ - 経過秒数
	expirationInSeconds := timestep - elapsedSecondsInCurrentWindow

	return expirationInSeconds
}

func main() {
	// タイムステップ（メンバー取得APIで得られるtimestep）
	timestep := int64(30)

	// 現在のタイムステップの残り秒数を出力
	fmt.Println(getTotpExpirationInSeconds(timestep))
}