TOTP எவ்வாறு செயல்படுகிறது: Python, JavaScript & Go-வில் RFC 6238 அல்காரிதம் செயல்படுத்தல்

import base64
import hashlib
import hmac
import struct
import time
def generate_totp(secret_base32: str, timestamp: int = None, step: int = 30, digits: int = 6) -> str:
"""
RFC 6238-க்கு இணக்கமான TOTP டோக்கனை உருவாக்குகிறது.
:param secret_base32: Base32 வடிவத்தில் பகிரப்பட்ட ரகசிய விசை (எ.கா: ‘JBSWY3DPEHPK3PXP’)
:param timestamp: வினாடிகளில் Unix epoch நேரமுத்திரை. முன்னிருப்பு time.time()
:param step: நேர சாளரம் வினாடிகளில் (முன்னிருப்பு: 30)
:param digits: வெளியீட்டு இலக்கங்களின் எண்ணிக்கை (முன்னிருப்பு: 6)
:return: பூஜ்ஜியம் நிரப்பப்பட்ட OTP சரம் (எ.கா: ‘045812’)
"""
if timestamp is None:
timestamp = int(time.time())
# 1. Base32 சரத்தை இயல்பாக்கி '=' பேடிங் எழுத்துக்களைச் சேர்க்கவும்
normalized_secret = secret_base32.replace(" ", "").upper()
padding_needed = (8 - len(normalized_secret) % 8) % 8
normalized_secret += "=" * padding_needed
key_bytes = base64.b32decode(normalized_secret)

# 2. 64-பிட் big-endian நேர-படி கவுண்டர் T-ஐக் கணக்கிடவும்
time_counter = timestamp // step
time_bytes = struct.pack(">Q", time_counter)  # 8 bytes big-endian unsigned long long

# 3. HMAC-SHA1 டைஜெஸ்ட்டைக் கணக்கிடவும் (20 பைட்டுகள்)
hmac_digest = hmac.new(key_bytes, time_bytes, hashlib.sha1).digest()

# 4. டைனமிக் ட்ரங்க்கேஷன் செயல்படுத்தவும்
offset = hmac_digest[-1] & 0x0F  # 20வது பைட்டின் கீழ் 4 பிட்கள்
# ஆஃப்செட்டில் உள்ள 4 பைட்டுகளை அன்-பேக் செய்து MSB சைன் பிட்டை நீக்கவும்
binary_code = struct.unpack(">I", hmac_digest[offset : offset + 4])[0] & 0x7FFFFFFF

# 5. மாடுலோ கணக்கீடு மற்றும் பூஜ்ஜிய நிரப்புதல் வடிவமைப்பு
otp_code = binary_code % (10 ** digits)
return str(otp_code).zfill(digits)

if name == “main”:
test_secret = “JBSWY3DPEHPK3PXP”
print(f”உருவாக்கப்பட்ட TOTP குறியீடு: {generate_totp(test_secret)}”)

const crypto = require('crypto');
// தூய JavaScript-ல் RFC 4648 Base32 டிகோடர்
function base32Decode(base32Str) {
const alphabet = ‘ABCDEFGHIJKLMNOPQRSTUVWXYZ234567’;
const cleaned = base32Str.replace(/=+$/, ”).toUpperCase().replace(/\s+/g, ”);
let bits = 0, value = 0, index = 0;
const output = new Uint8Array(Math.floor((cleaned.length * 5) / 8));
for (let i = 0; i < cleaned.length; i++) {
const val = alphabet.indexOf(cleaned[i]);
if (val === -1) continue;
value = (value << 5) | val;
bits += 5;
if (bits >= 8) {
output[index++] = (value >>> (bits - 8)) & 255;
bits -= 8;
}
}
return Buffer.from(output.buffer, 0, index);
}
function generateTOTP(secretBase32, timestamp = Math.floor(Date.now() / 1000), step = 30, digits = 6) {
const key = base32Decode(secretBase32);
const counter = Math.floor(timestamp / step);
// Big-Endian வடிவத்தில் 8-பைட் இடையகத்தை ஒதுக்கவும்
const buffer = Buffer.alloc(8);
buffer.writeBigUInt64BE(BigInt(counter), 0);
// HMAC-SHA1 கணக்கீடு
const hmac = crypto.createHmac(‘sha1’, key).update(buffer).digest();
// டைனமிக் ட்ரங்க்கேஷன்
const offset = hmac[hmac.length - 1] & 0x0f;
const binary = ((hmac[offset] & 0x7f) << 24) |
((hmac[offset + 1] & 0xff) << 16) |
((hmac[offset + 2] & 0xff) << 8) |
(hmac[offset + 3] & 0xff);
const otp = binary % (10 ** digits);
return otp.toString().padStart(digits, ‘0’);
}
console.log(“கணக்கிடப்பட்ட TOTP:”, generateTOTP(“JBSWY3DPEHPK3PXP”));

async function generateBrowserTOTP(secretBase32, timestamp = Math.floor(Date.now() / 1000)) {
  const keyBytes = base32Decode(secretBase32);
  const counter = Math.floor(timestamp / 30);
// 1. மூல ரகசிய விசையை SubtleCrypto-வில் இறக்குமதி செய்யவும்
const cryptoKey = await window.crypto.subtle.importKey(
“raw”,
keyBytes,
{ name: “HMAC”, hash: { name: “SHA-1” } },
false,
[“sign”]
);
// 2. 8-பைட் Big-Endian கவுண்டர் இடையகத்தை குறியாக்கம் செய்யவும்
const buffer = new ArrayBuffer(8);
const view = new DataView(buffer);
view.setBigUint64(0, BigInt(counter), false); // false = Big-Endian
// 3. கிரிப்டோகிராஃபிக் HMAC கையொப்பமிடுதல்
const signature = await window.crypto.subtle.sign(“HMAC”, cryptoKey, buffer);
const hmacResult = new Uint8Array(signature);
// 4. டைனமிக் ட்ரங்க்கேஷன்
const offset = hmacResult[hmacResult.length - 1] & 0x0f;
const binary = ((hmacResult[offset] & 0x7f) << 24) |
((hmacResult[offset + 1] & 0xff) << 16) |
((hmacResult[offset + 2] & 0xff) << 8) |
(hmacResult[offset + 3] & 0xff);
const otp = binary % 1000000;
return otp.toString().padStart(6, ‘0’);
}

package main
import (
“crypto/hmac”
“crypto/sha1”
“encoding/base32”
“encoding/binary”
“fmt”
“math”
“strings”
“time”
)
// GenerateTOTP நிலையான RFC 6238 நேர அடிப்படையிலான டோக்கன்களைக் கணக்கிடுகிறது
func GenerateTOTP(secretBase32 string, timestamp int64, step int64, digits int) (string, error) {
// 1. Base32 விதையைச் சுத்தப்படுத்தி டிகோட் செய்யவும்
cleaned := strings.ToUpper(strings.ReplaceAll(secretBase32, ” ”, ""))
key, err := base32.StdEncoding.WithPadding(base32.NoPadding).DecodeString(cleaned)
if err != nil {
key, err = base32.StdEncoding.DecodeString(cleaned)
if err != nil {
return "", err
}
}
// 2. 64-பிட் Big-Endian நேர-படி கவுண்டரை குறியாக்கம் செய்யவும்
counter := uint64(timestamp / step)
buf := make([]byte, 8)
binary.BigEndian.PutUint64(buf, counter)

// 3. HMAC-SHA1 கணக்கீடு
mac := hmac.New(sha1.New, key)
mac.Write(buf)
hash := mac.Sum(nil)

// 4. டைனமிக் ட்ரங்க்கேஷன்
offset := hash[len(hash)-1] & 0x0f
binaryCode := binary.BigEndian.Uint32(hash[offset:offset+4]) & 0x7fffffff

// 5. மாடுலோ கணக்கீடு
mod := uint32(math.Pow10(digits))
otp := binaryCode % mod

format := fmt.Sprintf("%%0%dd", digits)
return fmt.Sprintf(format, otp), nil

}
func main() {
code, err := GenerateTOTP(“JBSWY3DPEHPK3PXP”, time.Now().Unix(), 30, 6)
if err != nil {
panic(err)
}
fmt.Printf(“Golang கணக்கிட்ட TOTP: %s\n”, code)
}