移动虚拟会员卡安全技术咨询：动态码需支持离线使用

Great question—this is a super common pain point when building offline-capable secure credential systems, especially for in-store verification. The core tradeoff you’re facing is between preventing cloning/duplication, supporting offline use, and avoiding double-spending. Let’s break down three robust solutions that hit all three requirements:

1. Device-Bound Time-Synced OTP with Offline Validity Windows #

Instead of using a generic seed, tie your OTP generation to both time and a unique, non-exportable device identifier. Here’s how it works:

• When the user first onboards, your WebApp generates a cryptographically secure device fingerprint: use Web Crypto to create a persistent non-exportable key pair, then hash the public key to use as a unique device ID (stored securely in the browser’s key store, not plaintext).
• The server links this device ID to the user’s account and sends a unique seed only associated with that device.
• The WebApp generates OTPs using the seed, current timestamp (synced once on initial load, with a 2-5 minute tolerance for local clock drift), and a hash of the device ID.
• For offline use: Set a 10-15 minute validity window, stored on both the client and in-store terminals. When offline, the terminal validates the OTP locally by checking the timestamp window and verifying the device ID hash matches the cached user record.
• To prevent double-spending: Terminals log all used OTPs/device IDs locally, then sync logs to the server once online. The server flags duplicates and locks accounts for suspicious activity.

Pros: Relatively easy to implement, works on most browsers, balances offline use and security.
Cons: Requires careful clock drift handling, device ID spoofing is possible if not implemented with crypto-secure methods.

2. Offline-Signed One-Time Credentials with Post-Hoc Validation #

This approach shifts credential generation to the client using asymmetric cryptography, eliminating server-seeded OTPs entirely:

• On first load, the WebApp uses Web Crypto to generate a non-exportable RSA/ECDSA key pair. The public key is sent to the server and linked to the user’s account; the private key stays locked in the browser’s secure key store (can’t be exported or copied).
• When offline, the WebApp generates a payload like this:

  {
    userId: "user_789",
    timestamp: Date.now(),
    nonce: crypto.getRandomValues(new Uint8Array(16)) // Unique random value to block reuse
  }
  

• The payload is signed with the client’s private key, then encoded into a QR/barcode (using base64 or a compact binary format).
• In-store terminals cache valid user public keys locally. When offline, the terminal decodes the QR code, verifies the signature against the user’s public key, checks the timestamp window, and ensures the nonce hasn’t been used before (stored in a local encrypted log).
• Once online, terminals sync used nonces to the server, which cross-references them to prevent double-spending and flag invalid signatures.

Pros: No server seed to leak, private keys can’t be copied to other devices, robust offline support.
Cons: Requires careful public key caching on terminals, slightly more complex client-side crypto setup.

3. WebAuthn/CTAP for Hardware-Bound Credentials #

If you want maximum security (and your users have modern devices), WebAuthn is the gold standard. It leverages device hardware (Touch ID, Face ID, hardware security keys) to create unclonable credentials:

• During onboarding, the user registers their device via WebAuthn: the browser creates a hardware-bound private key, and the public key is sent to your server.
• When offline, the user triggers a WebAuthn assertion (e.g., scanning their fingerprint), which generates a signed payload containing the user ID, timestamp, and nonce. This payload is encoded into a QR code.
• In-store terminals validate the assertion using the user’s cached public key. Since the private key lives in the device’s secure hardware module, it can’t be extracted or copied—even if the user shares their WebApp session.
• Double-spending is prevented by logging nonces locally on terminals and syncing to the server post-connectivity.

Pros: Unclonable hardware-bound credentials, no server seeds, native browser support, highest security.
Cons: Requires user devices to support WebAuthn (most modern browsers/phones do, but older devices may not), slightly more complex integration.

Quick Implementation Tips #

• Time Sync: Use NTP on clients and terminals to minimize drift. Allow a small tolerance window for offline use.
• Device Revocation: Let users revoke lost/stolen devices via your portal. Push revocation lists to terminals periodically so they stop accepting invalid credentials.
• Terminal Caching: Store only necessary data (public keys, revocation lists) on terminals, and encrypt all cached data to prevent tampering.

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