使用ECC Curve25519在Java中加密/解密数据

1 回答

• 2

  加密Android设备上的文件的关键是永远不存储密钥 . 为此，您添加了加密图片不需要密码的约束 . 最后，因为非对称加密很慢，所以你需要使用AES来完成繁重的工作 .

  这适用于RSA或任何其他非对称算法 .

  Initial Run

  • 首次运行时，生成密钥对并要求用户输入密码 .

  • 将公钥存储为明文 . 使用密码生成的AES密钥加密私钥 .

  Encryption

  • 为每张图片生成不同的AES密钥，并使用它加密图像 . 使用公钥加密AES密钥并将其与图片一起存储 .

  Decryption

  • 让用户输入密码 . 从中生成第一个AES密钥 . 用它来解密私钥 . 使用私钥解密此图像的AES密钥 . 使用AES密钥解密文件并显示它 .

  （我们实际上有4个密钥 . 我们需要密钥对来允许我们在没有密码的情况下加密 . 我们需要第一个AES密钥来安全地存储私钥 . 我们需要第二个和更改AES密钥来加密文件 . ）

  我认为这应该是安全的，除了密钥记录等攻击 . Java代码应该非常简单 . 希望这很清楚 .

  ================================================== ====================

  完整示例使用AES和RSA . 对于Curve，仅切换RSA代码，虽然它不支持开箱即用，因此您需要一个外部库 . 此外，出于时间和简洁的考虑，代码的安全性应该低于应有的水平 . 例如，我使用的是ECB，而不是CBC .

  package il.co.falk;
  
  import javax.crypto.*;
  import javax.crypto.spec.PBEKeySpec;
  import javax.crypto.spec.SecretKeySpec;
  import java.security.*;
  import java.security.spec.KeySpec;
  import java.security.spec.PKCS8EncodedKeySpec;
  
  public class SecureFile {
  private PublicKey publicKey;
  private byte[] privateKeyArray;
  private byte[] salt = {1,2,3,4,5,6,7,8};
  
  
  public static void main(String[] args) {
      String password = "PASSWORD";
      SecureFile secureFile = new SecureFile(password);
      secureFile.test();
  }
  
  
  public void test() {
      String password = "PASSWORD";
      String imageFile = "348756348975634897562398479623896";
  
      ImageAndKey imageAndKey = encryptImage(imageFile.getBytes());
      byte[] decryptedImage = decryptImage(imageAndKey, password);
  
      System.out.println(new String(imageFile));
      System.out.println(new String(decryptedImage));
  }
  
  public SecureFile(String password) {
      try {
          generateRSAKeys(password);
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
  
  
  
  public ImageAndKey encryptImage(byte[] imageBytes) {
      try {
          byte[] secretKeyBytes = generateAESKey();
          byte[] encryptedFile = aesEncrypt(imageBytes, secretKeyBytes);
          byte[] encryptedKey = rsaEncrypt(secretKeyBytes);
  
          return new ImageAndKey(encryptedFile, encryptedKey);
      } catch (Exception e) {
          e.printStackTrace();
          return null;
      }
  
  }
  
  public byte[] decryptImage(ImageAndKey imageAndKey, String password) {
      try {
          byte[] secretKeyBytes = generateAESKey(password);
          byte[] decryptedPrivateKey = aesDecrypt(privateKeyArray, secretKeyBytes);
          byte[] decryptedKey = rsaDecrypt(imageAndKey.aesKey, decryptedPrivateKey);
  
          SecretKey secretKey = new SecretKeySpec(decryptedKey, "AES");
          secretKeyBytes = secretKey.getEncoded();
  
          byte[] decryptedBytes = aesDecrypt(imageAndKey.imageBytes, secretKeyBytes);
  
          return  decryptedBytes;
      } catch (Exception e) {
          e.printStackTrace();
      }
      return null;
  }
  
  
  
  // RSA
  private void generateRSAKeys(String password) throws Exception {
      final KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
      keyGen.initialize(512); // TODO: make this 2048 at least
      final KeyPair keyPair = keyGen.generateKeyPair();
      publicKey = keyPair.getPublic();
      PrivateKey privateKey = keyPair.getPrivate();
  
      byte[] secretKeyBytes = generateAESKey(password);
      byte[] privateKeyBytes = privateKey.getEncoded();
      privateKeyArray = aesEncrypt(privateKeyBytes, secretKeyBytes);
  }
  
  public byte[] rsaEncrypt(byte[] plainText) throws Exception {
      final Cipher cipher = Cipher.getInstance("RSA");
      cipher.init(Cipher.ENCRYPT_MODE, publicKey);
      byte[] cipherText = cipher.doFinal(plainText);
      return cipherText;
  }
  
  public byte[] rsaDecrypt(byte[] cipherText, byte[] decryptedPrivateKeyArray) throws Exception {
      PrivateKey privateKey = KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decryptedPrivateKeyArray));
  
      final Cipher cipher = Cipher.getInstance("RSA");
      cipher.init(Cipher.DECRYPT_MODE, privateKey);
      byte[]  plainText = cipher.doFinal(cipherText);
      return plainText;
  }
  
  // AES
  private byte[] aesEncrypt(byte[] plainText, byte[] secretKeyBytes) throws Exception {
      Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
      cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(secretKeyBytes));
      byte[] cipherText = cipher.doFinal(plainText);
      return cipherText;
  }
  
  public byte[] aesDecrypt(byte[] cipherText, byte[] secretKeyBytes) throws Exception {
      Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
      cipher.init(Cipher.DECRYPT_MODE, getSecretKey(secretKeyBytes));
      byte[] plainText = cipher.doFinal(cipherText);
      return plainText;
  }
  
  private byte[] generateAESKey() throws Exception {
      KeyGenerator keyGen = KeyGenerator.getInstance("AES");
      keyGen.init(256);
      SecretKey secretKey = keyGen.generateKey();
      return secretKey.getEncoded();
  }
  
  private byte[] generateAESKey(String password) throws Exception {
      SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
      KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 65536, 256);
      SecretKey tmp = factory.generateSecret(spec);
      SecretKey secret = new SecretKeySpec(tmp.getEncoded(), "AES");
      return secret.getEncoded();
  }
  
  private SecretKey getSecretKey(byte[] secretKeyBytes) throws Exception {
      SecretKey secretKey = new SecretKeySpec(secretKeyBytes, "AES");
      return secretKey;
  }
  
  
  
  // Classes
  class ImageAndKey {
      public byte[] imageBytes;
      public byte[] aesKey;
  
      public ImageAndKey(byte[] imageBytes, byte[] aesKey) {
          this.imageBytes = imageBytes;
          this.aesKey = aesKey;
      }
  }
  

  }

  回复于 2024-04-29T23:02:48+08:00