如何在C#中标记含authToken的临时URL访问一次即失效？

要实现带authToken的临时链接仅可访问一次，核心是跟踪每个Token的使用状态，并在验证时原子性标记为已使用。以下是具体实现方案：

1. 生成安全的一次性AuthToken #

必须使用加密强随机数生成Token，避免被猜测。不要使用Guid或普通Random类，推荐用RNGCryptoServiceProvider：

using System.Security.Cryptography;

public string GenerateOneTimeAuthToken()
{
    using var rng = new RNGCryptoServiceProvider();
    byte[] tokenBytes = new byte[32]; // 256位长度，足够抵御暴力破解
    rng.GetBytes(tokenBytes);
    
    // 转换为URL安全的Base64格式，替换特殊字符
    return Convert.ToBase64String(tokenBytes)
        .Replace('+', '-')
        .Replace('/', '_')
        .TrimEnd('=');
}

2. 存储Token状态（两种方案） #

根据部署场景选择存储方式：

方案A：单实例部署 - 内存缓存（IMemoryCache） #

适合单服务器应用，轻量高效：

using Microsoft.Extensions.Caching.Memory;

private readonly IMemoryCache _cache;
private const string TokenCachePrefix = "OneTimeToken_";

// 构造函数注入IMemoryCache
public TokenService(IMemoryCache cache)
{
    _cache = cache;
}

// 生成带Token的临时链接
public string CreateOneTimeLink()
{
    var token = GenerateOneTimeAuthToken();
    // 存入缓存，初始状态为false（未使用），并设置24小时过期时间
    _cache.Set(TokenCachePrefix + token, false, TimeSpan.FromHours(24));
    return $"http://example.com/ui/landing?authToken={token}";
}

方案B：多实例部署 - 分布式缓存（Redis） #

适合集群部署场景，确保多服务器状态一致（以StackExchange.Redis为例）：

using StackExchange.Redis;

private readonly IDatabase _redisDb;
private const string TokenCachePrefix = "OneTimeToken_";

// 构造函数注入Redis连接
public TokenService(IConnectionMultiplexer redis)
{
    _redisDb = redis.GetDatabase();
}

// 生成带Token的临时链接
public string CreateOneTimeLink()
{
    var token = GenerateOneTimeAuthToken();
    // Redis存入Token，值为"unused"，设置24小时过期
    _redisDb.StringSet(TokenCachePrefix + token, "unused", TimeSpan.FromHours(24));
    return $"http://example.com/ui/landing?authToken={token}";
}

3. 验证Token并标记为已使用 #

在接收请求的Action/接口中处理验证逻辑，必须保证原子性，防止同一Token被并发访问：

内存缓存验证逻辑 #

public IActionResult Landing(string authToken)
{
    if (string.IsNullOrEmpty(authToken))
        return BadRequest("无效链接");

    var cacheKey = TokenCachePrefix + authToken;
    
    // 尝试获取Token状态，并原子性更新为已使用
    if (_cache.TryGetValue(cacheKey, out bool isUsed))
    {
        if (!isUsed)
        {
            _cache.Set(cacheKey, true); // 标记为已使用
            return View(); // 处理正常访问逻辑
        }
        return BadRequest("无效链接");
    }
    return BadRequest("无效链接"); // Token不存在或已过期
}

Redis验证逻辑（原子操作） #

public async Task<IActionResult> Landing(string authToken)
{
    if (string.IsNullOrEmpty(authToken))
        return BadRequest("无效链接");

    var cacheKey = TokenCachePrefix + authToken;
    
    // 原子性获取原状态并设置为"used"，避免并发问题
    var previousValue = await _redisDb.StringGetSetAsync(cacheKey, "used");
    
    if (previousValue == "unused")
        return View(); // 正常访问
    return BadRequest("无效链接"); // 已使用或不存在
}

4. 备选：数据库持久化方案（审计需求） #

如果需要记录Token使用日志，可使用数据库存储（以EF Core为例）：

1. 定义实体类：

public class OneTimeToken
{
    public string Token { get; set; }
    public bool IsUsed { get; set; }
    public DateTime ExpiryTime { get; set; }
}

2. 验证逻辑（带事务）：

public async Task<IActionResult> Landing(string authToken)
{
    if (string.IsNullOrEmpty(authToken))
        return BadRequest("无效链接");

    using var transaction = await _dbContext.Database.BeginTransactionAsync();
    try
    {
        var tokenRecord = await _dbContext.OneTimeTokens
            .FirstOrDefaultAsync(t => t.Token == authToken && !t.IsUsed && t.ExpiryTime > DateTime.UtcNow);

        if (tokenRecord == null)
        {
            await transaction.RollbackAsync();
            return BadRequest("无效链接");
        }

        tokenRecord.IsUsed = true;
        await _dbContext.SaveChangesAsync();
        await transaction.CommitAsync();

        return View();
    }
    catch
    {
        await transaction.RollbackAsync();
        return BadRequest("无效链接");
    }
}

关键注意事项 #

• Token安全性：必须使用加密强随机数，避免被暴力破解。
• 过期时间：无论是否访问，都要设置过期时间，防止缓存/数据库膨胀。
• 并发处理：验证时必须用原子操作（内存缓存的Set、Redis的StringGetSet、数据库事务），防止同一Token被多次有效访问。
• 集群兼容性：多服务器部署时，不能用内存缓存，必须用分布式缓存或数据库。

内容的提问来源于stack exchange，提问作者KETAN KAKADE