jsencrypt

When handling encryption errors, avoid logging sensitive information such as the plaintext data or the private keys. Log metadata like the operation type, timestamp, and whether the key was loaded, but keep the actual secrets out of the logs.

class SecureEncryption {
    constructor(config) {
        this.crypt = new JSEncrypt(config);
        this.logger = config.logger || console;
    }
    
    encrypt(data) {
        try {
            const result = this.crypt.encrypt(data);
            if (!result) {
                // Log error without exposing sensitive data
                this.logger.error('Encryption failed', {
                    timestamp: new Date().toISOString(),
                    operation: 'encrypt',
                    keyLoaded: !!this.crypt.getKey()
                });
                throw new Error('Encryption operation failed');
            }
            return result;
        } catch (error) {
            // Don't log the actual data being encrypted
            this.logger.error('Encryption error', {
                error: error.message,
                stack: error.stack,
                timestamp: new Date().toISOString()
            });
            throw error;
        }
    }
    
    decrypt(ciphertext) {
        try {
            const result = this.crypt.decrypt(ciphertext);
            if (result === false) {
                this.logger.warn('Decryption failed', {
                    timestamp: new Date().toISOString(),
                    operation: 'decrypt',
                    ciphertextLength: ciphertext.length
                });
                throw new Error('Decryption failed');
            }
            return result;
        } catch (error) {
            // Log error without exposing plaintext or keys
            this.logger.error('Decryption error', {
                error: error.message,
                timestamp: new Date().toISOString()
            });
            throw error;
        }
    }
}

For production environments, wrap JSEncrypt in a layer that adds security metadata. This includes:

• Key Strength Validation: Ensure keys use standard headers (-----BEGIN PUBLIC KEY----- or -----BEGIN RSA PRIVATE KEY-----) and meet minimum length requirements (e.g., 2048 bits).
• Payload Integrity: Include a timestamp and a cryptographically secure nonce within the encrypted payload to prevent replay attacks and verify freshness.
• Expiration (TTL): When decrypting, verify the payload's timestamp against a maxAge threshold to ensure the data is not too old.
• Secure Randomness: Use window.crypto.getRandomValues in browsers or crypto.randomBytes in Node.js for generating nonces.

Security Checklist:

1. Never expose private keys in client-side code.
2. Use HTTPS for all communications.
3. Validate input data before encryption.
4. Use a minimum key size of 2048 bits for RSA.
5. Handle errors gracefully to avoid leaking sensitive information via error messages.

class ProductionEncryption {
    constructor(publicKey, privateKey) {
        const validation = SecurityUtils.validateKeyStrength(publicKey, privateKey);
        if (!validation.isValid) {
            console.warn('Key validation warnings:', validation.warnings);
        }
        
        this.crypt = new JSEncrypt();
        this.publicKey = publicKey;
        this.privateKey = privateKey;
    }
    
    encryptSecure(data, metadata = {}) {
        try {
            this.crypt.setPublicKey(this.publicKey);
            
            const payload = {
                data: data,
                timestamp: Date.now(),
                nonce: SecurityUtils.generateSecureRandom(16),
                ...metadata
            };
            
            const serialized = JSON.stringify(payload);
            const encrypted = this.crypt.encrypt(serialized);
            
            if (!encrypted) {
                throw new Error('Encryption failed');
            }
            
            return {
                success: true,
                encrypted: encrypted,
                timestamp: payload.timestamp
            };
        } catch (error) {
            return {
                success: false,
                error: error.message
            };
        }
    }
    
    decryptSecure(encryptedData, maxAge = 3600000) { // 1 hour default
        try {
            this.crypt.setPrivateKey(this.privateKey);
            
            const decrypted = this.crypt.decrypt(encryptedData);
            if (!decrypted) {
                throw new Error('Decryption failed');
            }
            
            const payload = JSON.parse(decrypted);
            
            const age = Date.now() - payload.timestamp;
            if (age > maxAge) {
                throw new Error('Data too old');
            }
            
            if (!payload.nonce) {
                throw new Error('Invalid payload format');
            }
            
            return {
                success: true,
                data: payload.data,
                timestamp: payload.timestamp,
                age: age
            };
        } catch (error) {
            return {
                success: false,
                error: error.message
            };
        }
    }
}

You can build an API token management system by combining signSha256() for token generation and verifySha256() for validation. A typical workflow involves:

1. Creating a JSON payload with user data and expiration.
2. Signing the payload string.
3. Encoding the payload and signature (e.g., via Base64) into a single token.
4. Decoding the token and verifying the signature against the payload before trusting the data.

class APITokenManager {
    constructor(privateKey, publicKey) {
        this.crypt = new JSEncrypt();
        this.privateKey = privateKey;
        this.publicKey = publicKey;
    }
    
    // Generate a signed API token
    generateToken(userId, permissions, expiresIn = 3600) {
        const tokenData = {
            userId: userId,
            permissions: permissions,
            issuedAt: Math.floor(Date.now() / 1000),
            expiresAt: Math.floor(Date.now() / 1000) + expiresIn
        };
        
        const payload = JSON.stringify(tokenData);
        this.crypt.setPrivateKey(this.privateKey);
        const signature = this.crypt.signSha256(payload);
        
        // Return token as base64 encoded payload + signature
        const token = Buffer.from(JSON.stringify({
            payload: payload,
            signature: signature
        })).toString('base64');
        
        return token;
    }
    
    // Validate an API token
    validateToken(token) {
        try {
            // Decode the token
            const decoded = JSON.parse(Buffer.from(token, 'base64').toString());
            const { payload, signature } = decoded;
            
            // Verify signature using convenience method
            this.crypt.setPublicKey(this.publicKey);
            const isValidSignature = this.crypt.verifySha256(payload, signature);
            
            if (!isValidSignature) {
                return { valid: false, reason: 'Invalid signature' };
            }
            
            // Check expiration
            const tokenData = JSON.parse(payload);
            const now = Math.floor(Date.now() / 1000);
            
            if (tokenData.expiresAt < now) {
                return { valid: false, reason: 'Token expired' };
            }
            
            return {
                valid: true,
                data: tokenData
            };
        } catch (error) {
            return { valid: false, reason: 'Invalid token format' };
        }
    }
}

RSA encryption has strict data length limits based on the key size. When implementing encryption, validate that the input is a string and that its length does not exceed the maximum allowed bytes (calculated as (keySize / 8) - 11 to account for PKCS#1 padding overhead).

function secureEncrypt(data, crypt) {
    // Validate input
    if (typeof data !== 'string') {
        throw new Error('Data must be a string');
    }
    
    // Check data length (RSA has size limits)
    const keySize = crypt.getKey().n.bitLength();
    const maxLength = Math.floor(keySize / 8) - 11; // PKCS#1 padding overhead
    
    if (data.length > maxLength) {
        throw new Error(`Data too long. Maximum length: ${maxLength} bytes`);
    }
    
    // Validate key is loaded
    if (!crypt.getKey()) {
        throw new Error('No encryption key loaded');
    }
    
    return crypt.encrypt(data);
}

Establish secure communication by encrypting data on the client side using the server's public key and decrypting it on the server side using the server's private key. The client can also decrypt server responses using its own private key.

// Client-side encryption
class SecureAPIClient {
    constructor(serverPublicKey, clientPrivateKey) {
        this.serverPublicKey = serverPublicKey;
        this.clientPrivateKey = clientPrivateKey;
        this.encryptor = new JSEncrypt();
        this.decryptor = new JSEncrypt();
        
        this.encryptor.setPublicKey(serverPublicKey);
        this.decryptor.setPrivateKey(clientPrivateKey);
    }
    
    async secureRequest(endpoint, data) {
        // Encrypt the request data
        const encryptedData = this.encryptor.encrypt(JSON.stringify(data));
        
        const response = await fetch(endpoint, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'X-Encrypted': 'true'
            },
            body: JSON.stringify({ encrypted: encryptedData })
        });
        
        const result = await response.json();
        
        // Decrypt the response
        if (result.encrypted) {
            const decryptedResponse = this.decryptor.decrypt(result.encrypted);
            return JSON.parse(decryptedResponse);
        }
        
        return result;
    }
}

// Usage
const client = new SecureAPIClient(serverPublicKey, clientPrivateKey);

const userData = await client.secureRequest('/api/user/profile', {
    userId: 12345,
    fields: ['name', 'email', 'preferences']
});