基于IP密钥的64字符字符串加密方案咨询（NodeJS环境）

Hey there! Let's walk through the best encryption solutions for your Node.js project, given your requirements: you need to encrypt a 64-character string with a user-provided IP address (could be IPv4 or IPv6), require high security + reversibility (so hashing is out), and can tolerate up to 20 seconds of processing time. Blowfish/Twofish are too outdated, so here are your top picks:

Top Recommended Schemes #

1. AES-256-GCM (Authenticated Encryption) #

This is the gold standard right now—NIST-recommended, provides both confidentiality and integrity (via authenticated encryption), and is natively supported in Node.js's crypto module. It's way more secure than Blowfish/Twofish, and even with key derivation steps, it'll finish way under your 20-second limit.

Key Notes:

• Since IP addresses (especially IPv4) don't have enough entropy to act as a direct encryption key, you'll need to use a Key Derivation Function (KDF) to stretch the IP into a strong, fixed-length key. PBKDF2 (native to Node.js) or Argon2 (more secure, requires a third-party package) work perfectly here.
• Always use a unique salt and IV for each encryption—never reuse them, as that compromises security.

Example Code:

First, using PBKDF2 (no extra dependencies):

const crypto = require('crypto');

// Derive a strong 256-bit key from the user's IP
function deriveKey(ip, salt) {
  // PBKDF2 with 100k iterations, SHA-256, 32-byte (256-bit) key
  return crypto.pbkdf2Sync(ip, salt, 100000, 32, 'sha256');
}

// Encrypt function
async function encryptText(plaintext, ip) {
  const salt = crypto.randomBytes(16); // Unique salt per encryption
  const iv = crypto.randomBytes(12); // GCM recommends 12-byte IV for optimal security
  const key = deriveKey(ip, salt);

  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
  let encrypted = cipher.update(plaintext, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  const authTag = cipher.getAuthTag().toString('hex');

  // Return salt, IV, auth tag, and ciphertext (all needed for decryption)
  return `${salt.toString('hex')}:${iv.toString('hex')}:${authTag}:${encrypted}`;
}

// Decrypt function
async function decryptText(encryptedData, ip) {
  const [saltHex, ivHex, authTagHex, ciphertextHex] = encryptedData.split(':');
  const salt = Buffer.from(saltHex, 'hex');
  const iv = Buffer.from(ivHex, 'hex');
  const authTag = Buffer.from(authTagHex, 'hex');
  const key = deriveKey(ip, salt);

  const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
  decipher.setAuthTag(authTag);
  let decrypted = decipher.update(ciphertextHex, 'hex', 'utf8');
  decrypted += decipher.final('utf8');

  return decrypted;
}

// Usage example
(async () => {
  const original = 'Your 64-character string here—e.g., abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678';
  const userIp = '192.168.1.1'; // Works with IPv6 too, e.g., '2001:db8::1'
  const encrypted = await encryptText(original, userIp);
  const decrypted = await decryptText(encrypted, userIp);
  console.log('Decrypted matches original:', original === decrypted); // Should log true
})();

If you want even stronger key derivation, use Argon2 (the winner of the Password Hashing Competition). You'll need to install the package first: npm install argon2, then adjust the key derivation step:

const argon2 = require('argon2');

async function deriveKeyWithArgon2(ip, salt) {
  const key = await argon2.hash(ip, {
    type: argon2.argon2id, // Balances speed and resistance to attacks
    salt: salt,
    memoryCost: 1 << 16, // 64MB memory usage (adjust if needed—still under 20s)
    timeCost: 3,
    parallelism: 2,
    raw: true // Return raw Buffer key instead of formatted hash
  });
  return key.slice(0, 32); // Ensure we get a 256-bit key
}

2. ChaCha20-Poly1305 #

If you're worried about AES performance on systems without hardware acceleration (though rare these days), ChaCha20-Poly1305 is another excellent AEAD option. It's just as secure as AES-GCM, and Node.js supports it natively. The code structure is almost identical to AES-GCM—just swap the algorithm string to chacha20-poly1305.

Quick Example Snippet:

// Encrypt with ChaCha20-Poly1305
const cipher = crypto.createCipheriv('chacha20-poly1305', key, iv);
// ... rest of the code is the same as AES-GCM

3. AES-256-CBC + HMAC (Legacy/Compatibility) #

If you need to work with older systems that don't support AEAD algorithms, you can combine AES-256-CBC (confidentiality) with HMAC-SHA256 (integrity). Note that this is less clean than AEAD because you have to handle two separate operations, but it's still secure if implemented correctly.

Critical Best Practices #

• Never reuse salts or IVs: Each encryption should generate a new salt and IV—store these alongside the ciphertext so you can decrypt later.
• Use AEAD algorithms (GCM/ChaCha20-Poly1305) when possible: They eliminate the need for separate integrity checks and reduce the chance of implementation mistakes.
• Test key derivation parameters: Adjust PBKDF2 iterations or Argon2 memory/time costs to fit within your 20-second window—you can crank them up for extra security since your time limit is generous.

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