加密与安全_TOTP 一次性密码生成算法

news2025/1/9 17:17:18

文章目录

  • Pre
  • TOTP是什么
  • TOTP 算法工作原理
  • TOTP 生成公式
  • TOTP 与 HOTP 的对比
  • Code
    • 生成TOTP
    • 验证 TOTP
    • 使用场景
    • 小结
  • TOTP 与 HOTP 的主要区别
  • TOTP 与 HOTP应用场景比较
  • TOTP 与 HOTP安全性分析

在这里插入图片描述

Pre

加密与安全_HTOP 一次性密码生成算法

https://github.com/samdjstevens/java-totp

https://medium.com/@rakesh.open.source/time-based-one-time-password-totp-java-implementation-82a472bd6bf9

https://gist.github.com/rakeshopensource/def80fac825c3e65804e0d080d2fa9a7

TOTP是什么

TOTP (Time-based One-Time Password) 是基于时间的动态密码生成算法，是 HOTP (基于HMAC的一次性密码) 的一个扩展。它的主要区别在于，TOTP 使用当前时间戳作为动态因子，而不是计数器。因此，生成的密码随时间变化，通常在一段时间（如30秒或60秒）内有效。

TOTP 算法工作原理

TOTP 使用当前时间戳与共享的密钥结合，生成一次性密码。以下是 TOTP 生成密码的主要步骤：

  1. 共享密钥：客户端和服务端预先共享一个密钥（通常是 Base32 编码），这和 HOTP 中的密钥是相同的。

  2. 时间戳：TOTP 使用当前时间戳，按时间步长（例如 30 秒）划分成时间段。每个时间段对应一个唯一的密码。

  3. 时间步数：将当前时间戳除以时间步长，得到时间步数。这个步数类似于 HOTP 中的计数器。

  4. HMAC 计算：使用共享的密钥和时间步数，使用 HMAC-SHA1 算法计算出一个哈希值。

  5. 截取密码：从 HMAC 的输出中提取 6 位或 8 位的动态密码。

TOTP 生成公式

TOTP 的生成公式如下：

TOTP = Truncate(HMAC-SHA-1(K, T))

其中：

  • K 是客户端和服务端之间的共享密钥。
  • T 是当前的时间步数，用公式 T = (currentUnixTime - T0) / X 计算。
    • currentUnixTime 是当前时间戳（以秒为单位）。
    • T0 是时间的起始点（一般为0）。
    • X 是时间步长（通常为30秒）。
  • HMAC-SHA-1 使用 K 作为密钥，对时间步数 T 进行 HMAC 计算。
  • Truncate 是截取函数，将 HMAC 的结果截取为 6 位或 8 位的数字。

TOTP 与 HOTP 的对比

  • 时间敏感 vs 计数敏感：TOTP 使用当前时间生成密码，因此密码是时间敏感的，每个密码只有在特定时间段内有效。HOTP 则基于计数器，每个密码对应一个计数器值。
  • 同步问题：TOTP 依赖于时间戳，因此客户端和服务端的时间需要保持同步，而 HOTP 需要计数器同步。

Code

生成TOTP

下面是一个简单的 TOTP 实现，生成 6 位的一次性密码。代码依赖于 javax.crypto.Mac 和 java.security.Key 类来处理 HMAC-SHA1。

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.ByteBuffer;
import java.util.Base32;
import java.util.TimeZone;
import java.time.Instant;
import java.time.Clock;

public class TOTP {

    // TOTP 生成算法
    public static String generateTOTP(String secret, long time, int digits) throws Exception {
        // 使用时间步长30秒
        long timeStep = 30;

        // 计算时间步数
        long t = time / timeStep;

        // 将密钥解码为字节
        Base32 base32 = new Base32();
        byte[] key = base32.decode(secret);

        // 使用 HMAC-SHA1 计算
        Mac mac = Mac.getInstance("HmacSHA1");
        SecretKeySpec keySpec = new SecretKeySpec(key, "HmacSHA1");
        mac.init(keySpec);

        // 将时间步数转换为 8 字节的大端字节数组
        byte[] timeBytes = ByteBuffer.allocate(8).putLong(t).array();

        // 计算 HMAC 值
        byte[] hash = mac.doFinal(timeBytes);

        // 提取动态截取码
        int offset = hash[hash.length - 1] & 0xf;
        int binary = ((hash[offset] & 0x7f) << 24)
                    | ((hash[offset + 1] & 0xff) << 16)
                    | ((hash[offset + 2] & 0xff) << 8)
                    | (hash[offset + 3] & 0xff);

        // 生成 OTP，取二进制数模10^digits，得到指定位数的OTP
        int otp = binary % (int) Math.pow(10, digits);

        // 格式化为指定位数
        return String.format("%0" + digits + "d", otp);
    }

    public static void main(String[] args) {
        try {
            // 示例密钥（注意：密钥应为 Base32 编码）
            String secret = "JBSWY3DPEHPK3PXP";

            // 获取当前 Unix 时间戳
            long currentTime = Instant.now().getEpochSecond();

            // 生成 TOTP
            String otp = generateTOTP(secret, currentTime, 6);

            System.out.println("生成的 OTP: " + otp);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代码解析

  1. 密钥解码：使用 Base32 解码器将字符串密钥解码为字节数组。在 TOTP 中，密钥通常以 Base32 编码存储。
  2. 时间步长：时间步长设为 30 秒，即 TOTP 密码每 30 秒更新一次。
  3. HMAC 计算：使用 HMAC-SHA1 算法，结合密钥和当前时间步数来计算哈希值。
  4. 动态截取：从哈希值中截取出一个 6 位的密码。

验证 TOTP

验证 TOTP 时，客户端和服务端必须在同一时间段内生成相同的密码。为了处理客户端与服务端之间的时间不同步问题，服务端可以允许一个时间窗口范围（例如 ±1 个时间步长）来容错。

为了验证 TOTP，服务端会接收用户输入的 OTP，并根据当前时间戳生成自己的 TOTP，进行比对。如果两者匹配，验证成功，否则失败。为了容错，服务端通常会允许一定的时间窗口来处理客户端和服务端之间可能存在的轻微时间不同步问题。

TOTP 验证流程：

  1. 当前时间戳计算：服务端根据当前时间戳生成 TOTP。
  2. 时间窗口：为了容错，服务端可以生成多个不同时间步内的 TOTP，通常是当前时间步及前后时间步。用户输入的 OTP 与服务端生成的这些 OTP 进行匹配。
  3. 密钥共享：TOTP 的核心是基于一个共享的密钥，客户端和服务端都必须使用同样的密钥生成 OTP。

验证TOTP的Java代码

package com.artisan.otp.totp;

import org.apache.commons.codec.binary.Base32;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.ByteBuffer;
import java.time.Instant;

/**
 * @author 小工匠
 * @version 1.0
 * @date 2024/10/2 9:37
 * @mark: show me the code , change the world
 */


public class TOTPValidator {

    /**
     * TOTP 生成算法（和生成 OTP 的算法一致）
     *
     * @param secret
     * @param time
     * @param digits
     * @return
     * @throws Exception
     */
    public static String generateTOTP(String secret, long time, int digits) throws Exception {
        // 时间步长，通常为30秒
        long timeStep = 30;

        // 将时间转换为时间步数
        long t = time / timeStep;

        // Base32 解码密钥
        Base32 base32 = new Base32();
        byte[] key = base32.decode(secret);

        // 使用 HMAC-SHA1
        Mac mac = Mac.getInstance("HmacSHA1");
        SecretKeySpec keySpec = new SecretKeySpec(key, "HmacSHA1");
        mac.init(keySpec);

        // 将时间步数转换为8字节的大端字节数组
        byte[] timeBytes = ByteBuffer.allocate(8).putLong(t).array();

        // 生成 HMAC 哈希值
        byte[] hash = mac.doFinal(timeBytes);

        // 提取动态截取码
        int offset = hash[hash.length - 1] & 0xf;
        int binary = ((hash[offset] & 0x7f) << 24)
                | ((hash[offset + 1] & 0xff) << 16)
                | ((hash[offset + 2] & 0xff) << 8)
                | (hash[offset + 3] & 0xff);

        // 生成指定位数的 OTP
        int otp = binary % (int) Math.pow(10, digits);
        // 格式化 OTP，确保是6位
        return String.format("%0" + digits + "d", otp);
    }

    /**
     * TOTP 验证算法
     * @param secret
     * @param inputOTP
     * @param window
     * @param digits
     * @return
     * @throws Exception
     */
    public static boolean validateTOTP(String secret, String inputOTP, int window, int digits) throws Exception {
        // 当前时间戳
        long currentTime = Instant.now().getEpochSecond();
        // 在前后时间步长的窗口内验证
        for (int i = -window; i <= window; i++) {
            String generatedOTP = generateTOTP(secret, currentTime + (i * 30), digits);
            System.out.println("Generated OTP: " + generatedOTP);
            if (generatedOTP.equals(inputOTP)) {
                // 验证成功
                return true;
            }
        }
        // 验证失败
        return false;
    }

    public static void main(String[] args) {
        try {
            // 示例密钥（注意：应为 Base32 编码）
            String secret = "JBSWY3DPEHPK3PXP";

            // 假设用户输入的 OTP（通常由客户端生成的 TOTP）
            // 示例 OTP，需要实际生成 TOTP
            String inputOTP = "306461";

            // 获取当前 Unix 时间戳
            long currentTime = Instant.now().getEpochSecond();

            // 生成 TOTP
            inputOTP = generateTOTP(secret, currentTime, 6);
            System.out.println("inputOTP: " +inputOTP);

            // 验证 OTP    容错窗口为1，6位OTP
            boolean isValid = validateTOTP(secret, inputOTP, 1, 6);

            if (isValid) {
                System.out.println("OTP 验证成功！");
            } else {
                System.out.println("OTP 验证失败！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代码说明

  1. generateTOTP: 生成 TOTP 的算法，使用当前时间戳和共享密钥生成一次性密码。
  2. validateTOTP: 验证用户输入的 OTP 是否有效。此函数允许一个时间窗口（window），比如前后 30 秒范围内的 OTP 都可接受。默认 6 位 OTP。
  3. Base32 解码: Base32 编码用于解码密钥，因为密钥通常以 Base32 编码形式存储。
  4. 时间步长: TOTP 的时间步长通常是 30 秒。代码中以当前时间为基准，根据时间步长计算时间步数，生成 OTP。
  5. 容错窗口: 允许服务端生成当前时间步以及前后若干步内的 OTP，防止客户端与服务端时间不同步。

如何使用

  1. 密钥一致: 确保客户端和服务端使用同一个共享密钥。密钥通常是 Base32 编码的字符串。
  2. 验证 OTP: 服务端使用当前时间步生成 TOTP，并与用户输入的 OTP 进行比对。如果在设定的时间窗口内有匹配的 OTP，验证成功。

调试步骤

  1. 打印调试信息: 在生成和验证过程中打印 OTP 和相关的时间步，帮助确认时间步数和生成的 OTP 是否一致。
  2. 调整时间窗口: 如果客户端和服务端的时间差异较大，尝试增加 window 的大小，允许更大的容错范围。
    在这里插入图片描述

这个实现适用于 TOTP 的典型应用场景，例如双因素认证 (2FA)【基于时间的一次性密码生成和验证】。

使用场景

  • 双因素认证 (2FA)：TOTP 是常见的 2FA 算法之一，用户使用手机中的身份验证器（如 Google Authenticator）生成一次性密码进行登录验证。
  • 高安全性系统：银行、电子商务网站等需要额外的安全措施，使用 TOTP 来防止密码泄露和账户被劫持。

小结

TOTP 是一种基于时间的动态密码算法，通过时间戳和共享密钥生成一次性密码，常用于双因素身份验证场景。相比于 HOTP，TOTP 不需要计数器同步，使用更加便捷，但要求客户端和服务端的时间同步。

TOTP 与 HOTP 的主要区别

特点HOTPTOTP
依赖性计数器时间戳
密码有效性永久有效，直到被使用短时间内有效（30 或 60 秒）
生成方式每次生成后计数器递增每个时间周期内自动生成
安全性密码可能长期有效，安全性较低动态更新，安全性更高
适用场景适用于基于事件的认证系统适用于二次身份验证系统

TOTP 与 HOTP应用场景比较

  • HOTP 适用场景：

    • 基于事件触发的认证系统：每次用户请求认证时，系统会递增计数器生成密码。这类系统适用于需要物理令牌或硬件设备的场景（如早期银行安全令牌）。
    • 设备或网络不稳定环境：由于 HOTP 不依赖时间，客户端和服务器的时间不同步问题不会影响认证。

  • TOTP 适用场景：

    • 二次身份验证（2FA）：TOTP 在大多数现代的二次身份验证系统中使用，如 Google Authenticator、Microsoft Authenticator 等。用户每 30 秒生成一个新密码，确保密码及时失效。
    • 需要更高安全性和频繁登录的系统：由于 TOTP 密码动态更新且过期较快，适合频繁使用和安全性要求较高的应用。

TOTP 与 HOTP安全性分析

  • HOTP 的安全性弱点：由于 HOTP 密码在未使用前一直有效，攻击者可以通过拦截未被使用的密码进行重放攻击，或暴力猜测计数器值。
  • TOTP 的安全优势：TOTP 基于时间戳生成，密码的有效期较短（通常 30 秒）。即使攻击者截获密码，也很难在其
    过期前使用，因此 TOTP 提供了更强的安全性。

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2185645.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

YOLO11改进|卷积篇|引入可变核卷积AKConv

YOLO11改进|卷积篇|引入可变核卷积AKConv

目录 一、AKConv卷积1.1AKConv卷积介绍1.2MLCA核心代码 五、添加MLCA注意力机制5.1STEP15.2STEP25.3STEP35.4STEP4 六、yaml文件与运行6.1yaml文件6.2运行成功截图 一、AKConv卷积 1.1AKConv卷积介绍 AKConv允许卷积参数的数量以线性方式增加或减少&#xff0c;而不是传统的平…
阅读更多...
C# 表达式与运算符

C# 表达式与运算符

本课要点&#xff1a; 1、表达式的基本概念 2、常用的几种运算符 3、运算符的优先级 4、常见问题 一 表达式 表达式是由运算符和操作数组成的。、-、*和/等都是运算符&#xff0c;操作数包括文本、常量、变量和表达式等。 二 算术运算符 2.1 算术运算符的使用 三 常见错误 …
阅读更多...
Cocotb 学习记录--V01

Cocotb 学习记录--V01

1. Windows 下安装cocotb pip install cocotb 其他参考&#xff1a; 1.Welcome to cocotb’s documentation! — cocotb 1.9.1 documentation
阅读更多...
【Koa】文件上传

【Koa】文件上传

主要使用两个 koa 插件&#xff0c;koa-body 里面自带文件上传功能&#xff0c;还有一个 koa-staitc 用于配置静态资源目录&#xff08;可以通过路径直接访问图片&#xff09;。 router const Router require(koa/router); const {upload} require(../controller/user);con…
阅读更多...
Spring之生成Bean

Spring之生成Bean

Bean的生命周期&#xff1a;实例化->属性填充->初始化->销毁 核心入口方法&#xff1a;finishBeanFactoryInitialization-->preInstantiateSingletons DefaultListableBeanFactory#preInstantiateSingletons用于实例化非懒加载的bean。 1.preInstantiateSinglet…
阅读更多...
【RADARSAT Constellation Mission（RCM）卫星星座简介】

【RADARSAT Constellation Mission（RCM）卫星星座简介】

RADARSAT Constellation Mission&#xff08;RCM&#xff09;卫星星座是加拿大太空局&#xff08;CSA&#xff09;的下一代C波段合成孔径雷达&#xff08;SAR&#xff09;卫星星座&#xff0c;以下是对其的详细介绍&#xff1a; 一、基本信息 发射时间&#xff1a;2019年6月…
阅读更多...
Golang | Leetcode Golang题解之第452题用最少数量的箭引爆气球

Golang | Leetcode Golang题解之第452题用最少数量的箭引爆气球

题目&#xff1a; 题解&#xff1a; func findMinArrowShots(points [][]int) int {if len(points) 0 {return 0}sort.Slice(points, func(i, j int) bool { return points[i][1] < points[j][1] })maxRight : points[0][1]ans : 1for _, p : range points {if p[0] > …
阅读更多...
秒懂Linux之线程

秒懂Linux之线程

目录 线程概念 线程理解 地址空间&#xff08;页表&#xff0c;内存&#xff0c;虚拟地址&#xff09; 线程的控制 铺垫 线程创建 ​编辑 线程等待 线程异常 线程终止 代码 线程优点 线程缺点 线程特点 线程概念 线程是进程内部的一个执行分支&#xff0c;线程是C…
阅读更多...
小程序-全局数据共享

小程序-全局数据共享

目录 1.什么是全局数据共享 2. 小程序中的全局数据共享方案 MboX 1. 安装 MobX 相关的包 2. 创建 MobX 的 Store 实例 3. 将 Store 中的成员绑定到页面中 4. 在页面上使用 Store 中的成员 5. 将 Store 中的成员绑定到组件中 6. 在组件中使用 Store 中的成员 1.什么是全…
阅读更多...
【LeetCode】每日一题 2024_10_2 准时到达的列车最小时速（二分答案）

【LeetCode】每日一题 2024_10_2 准时到达的列车最小时速（二分答案）

前言 每天和你一起刷 LeetCode 每日一题~ 大家国庆节快乐呀~ LeetCode 启动&#xff01; 题目&#xff1a;准时到达的列车最小时速 代码与解题思路 今天这道题是经典的二分答案&#xff0c;结合这道题来讲就是&#xff0c;二分列车的速度 我最擅长的两个算法&#xff1a;一…
阅读更多...
cGANs with Projection Discriminator

cGANs with Projection Discriminator

基于映射鉴别器的CGAN 模型中&#xff0c;判别器&#xff08;Discriminator&#xff09;不是通过将条件信息简单地与特征向量拼接&#xff08;concatenate&#xff09;来使用条件信息&#xff0c;而是采用一种基于投影的方式&#xff0c;这种方式更加尊重条件信息在底层概率模…
阅读更多...
进程通信——内存映射

进程通信——内存映射

进程通信——内存映射 什么是内存映射 内存映射是一种将文件内容映射到进程地址空间的技术&#xff0c;使得进程可以直接访问文件内容&#xff0c;而不需要通过系统调用进行读写操作。内存映射可以提高文件访问的效率&#xff0c;并且可以实现进程间的通信。 内存映射的原理…
阅读更多...
【HarmonyOS】时间处理Dayjs

【HarmonyOS】时间处理Dayjs

背景 在项目中经常会使用要时间的格式转换&#xff0c;比如数据库返回一个Date数据&#xff0c;你需要转成2024-10-2的格式&#xff0c;鸿蒙的原生SDK中是没有办法实现的&#xff0c;因此&#xff0c;在这里介绍第三方封装好并且成熟使用的库Dayjs。 安装 切换到Entry文件夹下…
阅读更多...
C++初学者指南-5.标准库(第二部分)–特殊迭代器

C++初学者指南-5.标准库(第二部分)–特殊迭代器

C初学者指南-5.标准库(第二部分)–特殊迭代器 文章目录 C初学者指南-5.标准库(第二部分)–特殊迭代器容器操纵器std::insert_iterator\<Container>std::back_insert_iterator\<Container>std::front_insert_iterator\<Container> I/O 流迭代器std::istream_i…
阅读更多...
2024大二上js高级+ES6学习9.29（深/浅拷贝，正则表达式，let/const，解构赋值，箭头函数，剩余参数）

2024大二上js高级+ES6学习9.29（深/浅拷贝，正则表达式，let/const，解构赋值，箭头函数，剩余参数）

9.29.2024 1.浅拷贝和深拷贝 Es6的语法糖&#xff1a;用assign将obj对象浅拷贝给o对象。 把数组写在前面是因为数组也是对象 2.正则表达式 创建和检测正则表达式 正则表达式的使用直接跳过&#xff0c;等要用时现查现用 3.ES6 4.let关键字 块级作用域是指在一个{}l里 变量提…
阅读更多...
Python | Leetcode Python题解之第441题排列硬币

Python | Leetcode Python题解之第441题排列硬币

题目&#xff1a; 题解&#xff1a; class Solution:def arrangeCoins(self, n: int) -> int:left, right 1, nwhile left < right:mid (left right 1) // 2if mid * (mid 1) < 2 * n:left midelse:right mid - 1return left
阅读更多...
四、Java 基础语法

四、Java 基础语法

一、Java 的类、对象、方法和实例变量 一个 Java 程序可以认为是一系列对象的集合&#xff0c;而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。对象&#xff1a;对象是类的一个实例&#xff0c;有状态&#xff08;实例变量&#xff…
阅读更多...
MySQL基础练习题49-低质量的问题

MySQL基础练习题49-低质量的问题

目录 题目 准备数据 分析数据 总结 题目 找出 低质量 问题的 ID 集合。如果一个力扣问题的喜欢率&#xff08;喜欢数除以总投票数&#xff09;严格低于 60% &#xff0c;则该问题为低质量问题。 按 problem_id 升序排列返回结果表。 准备数据 Create table If Not Exis…
阅读更多...
深度学习基础—卷积神经网络示例

深度学习基础—卷积神经网络示例

1.卷积神经网络的结构 在之前的博客《深度学习—简单的卷积神经网络》&#xff0c;仅由卷积层构成网络的全部&#xff0c;这还不是标准的网络结构&#xff0c;本文将继续介绍标准的卷积神经网络结构有哪些&#xff1f; 深度学习基础—简单的卷积神经网络https://blog.csdn.net…
阅读更多...
STM32-按键控制LED 光敏传感器控制蜂鸣器(江协笔记)

STM32-按键控制LED 光敏传感器控制蜂鸣器(江协笔记)

1、按键 2、常见传感器模块 R1 定值电阻 N1 传感器电阻。对于光敏传感器来说&#xff0c;相当于光敏电阻&#xff1b;...... C(滤波电容) 给中间的电压输出进行滤波&#xff0c;用于滤除一些干扰&#xff0c;保证输出电压波形的平滑&#xff08;保持电路稳定&#xff09; …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023