O Advanced Encryption Standard (AES) é um algoritmo de criptografia simétrica amplamente adotado na indústria, caracterizado pelo uso de uma única chave secreta comaprtilhada para os processos de cifragem e decirfagem. Em aplicações web modernas, é uma prática recomendada utilizar essa técnica para proteger credenciais sensíveis, como senhas, durante o tráfego em requisições HTTP. Ao criptografar os dados no lado do cliente e decifrá-los no servidor, mitigamos significativamente os riscos de interceptação de pacotes e exposição de informações em texto claro.

Criptografia no Frontend com JavaScript

No ecossistema JavaScript, a biblioteca crypto-js é a escolha padrão para lidar com padrões criptográficos de forma simplificada. Para integrar a solução ao seu projeto, instale o pacote via gerenciador de dependências:

npm install crypto-js

Abaixo, apresentamos um módulo utilitário que encapsula as operações de cifragem e decifragem. Note que a chave secreta deve ter exatamente 16 bytes (128 bits) para garantir a compatibilidade com o padrão AES-128.

import CryptoJS from 'crypto-js';

const SECRET_PHRASE = 'A1B2C3D4E5F6G7H8';
const utf8Key = CryptoJS.enc.Utf8.parse(SECRET_PHRASE);

const AesHelper = {
  cipherText(plainData) {
    const parsedData = CryptoJS.enc.Utf8.parse(plainData);
    const encrypted = CryptoJS.AES.encrypt(parsedData, utf8Key, {
      mode: CryptoJS.mode.ECB,
      padding: CryptoJS.pad.Pkcs7
    });
    return encrypted.toString();
  },

  plainText(encryptedData) {
    const decrypted = CryptoJS.AES.decrypt(encryptedData, utf8Key, {
      mode: CryptoJS.mode.ECB,
      padding: CryptoJS.pad.Pkcs7
    });
    return decrypted.toString(CryptoJS.enc.Utf8);
  }
};

export default AesHelper;

Decifragem no Backend com Java

No ambiente Java, as operações criptográficas são nativamente suportadas pelo pacote javax.crypto. A implementação a seguir demonstra uma classe utilitária que espelha a configuração do front end, utilizando o modo ECB e preenchimento (padding) compatível. O texto cifrado é transportado em formato Base64, que é decodificado antes da operação criptográfica final.

package com.security.crypto;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class AesCipherUtil {

    private static final String TRANSFORMATION = "AES/ECB/PKCS5Padding";
    private static final String ALGORITHM = "AES";
    
    // Deve ser exatamente a mesma chave de 16 bytes utilizada no frontend
    private static final byte[] SECRET_KEY_BYTES = "A1B2C3D4E5F6G7H8".getBytes(StandardCharsets.UTF_8);

    private static SecretKeySpec buildKeySpec() {
        return new SecretKeySpec(SECRET_KEY_BYTES, ALGORITHM);
    }

    public static String encode(String rawData) throws Exception {
        Cipher cipherEngine = Cipher.getInstance(TRANSFORMATION);
        cipherEngine.init(Cipher.ENCRYPT_MODE, buildKeySpec());
        byte[] encryptedBytes = cipherEngine.doFinal(rawData.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }

    public static String decode(String encodedData) throws Exception {
        Cipher cipherEngine = Cipher.getInstance(TRANSFORMATION);
        cipherEngine.init(Cipher.DECRYPT_MODE, buildKeySpec());
        byte[] decodedBytes = Base64.getDecoder().decode(encodedData);
        byte[] decryptedBytes = cipherEngine.doFinal(decodedBytes);
        return new String(decryptedBytes, StandardCharsets.UTF_8);
    }
}