选择Java加密算法第2部分–单密钥对称加密

最新推荐文章于 2023-07-10 18:35:37 发布
最新推荐文章于 2023-07-10 18:35:37 发布
阅读量161 收藏
点赞数
文章标签： java 加密解密 密码学 数据库 linux

抽象

这是涵盖Java加密算法的三部分博客系列的第2部分。 本系列介绍如何实现以下目标：

  1. 使用SHA–512散列
  2. AES–256
  3. RSA–4096

这第二篇文章详细介绍了如何实现单密钥对称AES-256加密。 让我们开始吧。

免责声明

这篇文章仅供参考。 在使用所提供的任何信息之前，请认真思考。 从中学到东西，但最终自己做出决定，风险自负。

要求

我使用以下主要技术完成了本文的所有工作。 您可能可以使用不同的技术或版本来做相同的事情，但不能保证。

下载

访问我的GitHub页面以查看我所有的开源项目。 这篇文章的代码位于项目中： thoth-cryptography

对称加密

关于

对称加密算法基于单个密钥。 此密钥用于加密和解密。 因此，对称算法仅应在严格控制密钥的地方使用。

对称算法通常用于安全环境中的数据加密和解密。 一个很好的例子是确保微服务通信的安全。 如果OAuth-2 / JWT体系结构超出范围，则API网关可以使用对称算法的单个密钥来加密令牌。 然后将此令牌传递给其他微服务。 其他微服务使用相同的密钥来解密令牌。 另一个很好的例子是电子邮件中嵌入的超链接。 电子邮件中的超链接包含一个编码的令牌，当单击该超链接时，该令牌允许自动登录请求处理。 此令牌是由对称算法生成的高度加密的值，因此只能在应用程序服务器上解码。 当然，任何时候都需要保护任何类型的密码或凭证，使用对称算法对它们进行加密，然后可以使用相同的密钥对字节进行解密。

截止目前的研究似乎表明，以下是最佳，最安全的单密钥，对称加密算法（Sheth，2017年，“选择正确的算法”，第2段）：

  1. 算法： AES
  2. 模式： GCM
  3. 填充： PKCS5Padding
  4. 密钥大小： 256位
  5. IV大小： 96位

AES–256使用256位密钥， 需要安装Java密码学扩展（JCE）无限强度软件包。 让我们看一个例子。

注意： 256位密钥需要Java密码术扩展（JCE）无限强度软件包。 如果未安装，则最大为128位密钥。

例

如果尚未安装，请下载并安装Java Cryptography Extension（JCE）无限强度软件包。 需要使用256位密钥。 否则，必须将以下示例更新为使用128位密钥。

清单1是AesTest.java单元测试。 这是以下内容的完整演示：

  1. 生成并存储AES 256位密钥
  2. AES加密
  3. AES解密

清单2显示了AesSecretKeyProducer.java 。 这是一个帮助程序类，负责产生一个新密钥或从byte[]复制一个现有密钥。

清单3显示了ByteArrayWriter.java ，清单4显示了ByteArrayReader.java 。 这些是帮助程序类，负责将byte[]读写到文件中。 由您决定如何存储密钥的byte[] ，但是需要将其安全地存储在某个地方（文件，数据库，git存储库等）。

最后，清单5显示了Aes.java 。 这是一个帮助程序类，负责加密和解密。

清单1 – AesTest.java类 

package org.thoth.crypto.symmetric;

import java.io.ByteArrayOutputStream;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Optional;
import javax.crypto.SecretKey;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import org.thoth.crypto.io.ByteArrayReader;
import org.thoth.crypto.io.ByteArrayWriter;

/**
 *
 * @author Michael Remijan mjremijan@yahoo.com @mjremijan
 */
public class AesTest {

    static Path secretKeyFile;

    @BeforeClass
    public static void beforeClass() throws Exception {
        // Store the SecretKey bytes in the ./target diretory. Do
        // this so it will be ignore by source control.  We don't
        // want this file committed.
        secretKeyFile
            = Paths.get("./target/Aes256.key").toAbsolutePath();

        // Generate a SecretKey for the test
        SecretKey secretKey
            = new AesSecretKeyProducer().produce();

        // Store the byte[] of the SecretKey.  This is the
        // "private key file" you want to keep safe.
        ByteArrayWriter writer = new ByteArrayWriter(secretKeyFile);
        writer.write(secretKey.getEncoded());
    }


    @Test
    public void encrypt_and_decrypt_using_same_Aes256_instance() {
        // setup
        SecretKey secretKey
            = new AesSecretKeyProducer().produce(
                new ByteArrayReader(secretKeyFile).read()
            );

        Aes aes
            = new Aes(secretKey);

        String toEncrypt
            = "encrypt me";

        // run
        byte[] encryptedBytes
            = aes.encrypt(toEncrypt, Optional.empty());

        String decrypted
            = aes.decrypt(encryptedBytes, Optional.empty());

        // assert
        Assert.assertEquals(toEncrypt, decrypted);
    }


    public void encrypt_and_decrypt_with_aad_using_same_Aes256_instance() {
        // setup
        SecretKey secretKey
            = new AesSecretKeyProducer().produce(
                new ByteArrayReader(secretKeyFile).read()
            );

        Aes aes
            = new Aes(secretKey);

        String toEncrypt
            = "encrypt me aad";

        // run
        byte[] encryptedBytes
            = aes.encrypt(toEncrypt, Optional.of("JUnit AAD"));

        String decrypted
            = aes.decrypt(encryptedBytes, Optional.of("JUnit AAD"));

        // assert
        Assert.assertEquals(toEncrypt, decrypted);
    }


    @Test
    public void encrypt_and_decrypt_using_different_Aes256_instance()
    throws Exception {
        // setup
        SecretKey secretKey
            = new AesSecretKeyProducer().produce(
                new ByteArrayReader(secretKeyFile).read()
            );

        Aes aesForEncrypt
            = new Aes(secretKey);

        Aes aesForDecrypt
            = new Aes(secretKey);

        String toEncrypt
            = "encrypt me";

        // run
        byte[] encryptedBytes
            = aesForEncrypt.encrypt(toEncrypt, Optional.empty());

        ByteArrayOutputStream baos
            = new ByteArrayOutputStream();
        baos.write(encryptedBytes);

        String decrypted
            = aesForDecrypt.decrypt(baos.toByteArray(), Optional.empty());

        // assert
        Assert.assertEquals(toEncrypt, decrypted);
    }
}

清单2 – AesSecretKeyProducer.java类 

package org.thoth.crypto.symmetric;

import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

/**
 *
 * @author Michael Remijan mjremijan@yahoo.com @mjremijan
 */
public class AesSecretKeyProducer {

    /**
     * Generates a new AES-256 bit {@code SecretKey}.
     *
     * @return {@code SecretKey}, never null
     * @throws RuntimeException All exceptions are caught and re-thrown as {@code RuntimeException}
     */
    public SecretKey produce() {
        KeyGenerator keyGen;
        try {
            keyGen = KeyGenerator.getInstance("AES");
            keyGen.init(256);
            SecretKey secretKey = keyGen.generateKey();
            return secretKey;
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }


    /**
     * Generates an AES-256 bit {@code SecretKey}.
     *
     * @param encodedByteArray The bytes this method will use to regenerate a previously created {@code SecretKey}
     *
     * @return {@code SecretKey}, never null
     * @throws RuntimeException All exceptions are caught and re-thrown as {@code RuntimeException}
     */
    public SecretKey produce(byte [] encodedByteArray) {
        try {
            return new SecretKeySpec(encodedByteArray, "AES");
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }
}

清单3 – ByteArrayWriter.java类 

package org.thoth.crypto.io;

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Path;

/**
 *
 * @author Michael Remijan mjremijan@yahoo.com @mjremijan
 */
public class ByteArrayWriter {

    protected Path outputFile;

    private void initOutputFile(Path outputFile) {
        this.outputFile = outputFile;
    }

    private void initOutputDirectory() {
        Path outputDirectory = outputFile.getParent();
        if (!Files.exists(outputDirectory)) {
            try {
                Files.createDirectories(outputDirectory);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public ByteArrayWriter(Path outputFile) {
        initOutputFile(outputFile);
        initOutputDirectory();
    }

    public void write(byte[] bytesArrayToWrite) {
        try (
            OutputStream os
                = Files.newOutputStream(outputFile);

            PrintWriter writer
                =  new PrintWriter(os);
        ){
            for (int i=0; i<bytesArrayToWrite.length; i++) {
                if (i>0) {
                    writer.println();
                }
                writer.print(bytesArrayToWrite[i]);
            }
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
    }
}

清单4 – ByteArrayReader.java类 

package org.thoth.crypto.io;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.file.Path;
import java.util.Scanner;

/**
 *
 * @author Michael Remijan mjremijan@yahoo.com @mjremijan
 */
public class ByteArrayReader {

    protected Path inputFile;

    public ByteArrayReader(Path inputFile) {
        this.inputFile = inputFile;
    }

    public byte[] read() {
        try (
            Scanner scanner
                =  new Scanner(inputFile);

            ByteArrayOutputStream baos
                = new ByteArrayOutputStream();
        ){
            while (scanner.hasNext()) {
                baos.write(Byte.parseByte(scanner.nextLine()));
            }
            
            baos.flush();
            return baos.toByteArray();

        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
    }
}

清单5 – Aes.java类 

package org.thoth.crypto.symmetric;

import java.security.SecureRandom;
import java.util.Optional;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.GCMParameterSpec;

/**
 *
 * @author Michael Remijan mjremijan@yahoo.com @mjremijan
 */
public class Aes {

    // If you don't have the Java Cryptography Extension
    // (JCE) Unlimited Strength packaged installed, use
    // a 128 bit KEY_SIZE.
    public static int KEY_SIZE = 256;
    
    public static int IV_SIZE = 12; // 12bytes * 8 = 96bits
    public static int TAG_BIT_SIZE = 128;
    public static String ALGORITHM_NAME = "AES";
    public static String MODE_OF_OPERATION = "GCM";
    public static String PADDING_SCHEME = "PKCS5Padding";

    protected SecretKey secretKey;
    protected SecureRandom secureRandom;

    public Aes(SecretKey secretKey) {
        this.secretKey = secretKey;
        this.secureRandom = new SecureRandom();
    }


    public byte[] encrypt(String message, Optional<String> aad) {
        try {
            // Transformation specifies algortihm, mode of operation and padding
            Cipher c = Cipher.getInstance(
                String.format("%s/%s/%s",ALGORITHM_NAME,MODE_OF_OPERATION,PADDING_SCHEME)
            );

            // Generate IV
            byte iv[] = new byte[IV_SIZE];
            secureRandom.nextBytes(iv); // SecureRandom initialized using self-seeding

            // Initialize GCM Parameters
            GCMParameterSpec spec = new GCMParameterSpec(TAG_BIT_SIZE, iv);

            // Init for encryption
            c.init(Cipher.ENCRYPT_MODE, secretKey, spec, secureRandom);

            // Add AAD tag data if present
            aad.ifPresent(t -> {
                try {
                    c.updateAAD(t.getBytes("UTF-8"));
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            });

            // Add message to encrypt
            c.update(message.getBytes("UTF-8"));

            // Encrypt
            byte[] encryptedBytes
                = c.doFinal();


            // Concatinate IV and encrypted bytes.  The IV is needed later
            // in order to to decrypt.  The IV value does not need to be
            // kept secret, so it's OK to encode it in the return value
            //
            // Create a new byte[] the combined length of IV and encryptedBytes
            byte[] ivPlusEncryptedBytes = new byte[iv.length + encryptedBytes.length];
            // Copy IV bytes into the new array
            System.arraycopy(iv, 0, ivPlusEncryptedBytes, 0, iv.length);
            // Copy encryptedBytes into the new array
            System.arraycopy(encryptedBytes, 0, ivPlusEncryptedBytes, iv.length, encryptedBytes.length);

            // Return
            return ivPlusEncryptedBytes;

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }


    public String decrypt(byte[] ivPlusEncryptedBytes, Optional<String> aad) {

        try {
            // Get IV
            byte iv[] = new byte[IV_SIZE];
            System.arraycopy(ivPlusEncryptedBytes, 0, iv, 0, IV_SIZE);

            // Initialize GCM Parameters
            GCMParameterSpec spec = new GCMParameterSpec(TAG_BIT_SIZE, iv);

            // Transformation specifies algortihm, mode of operation and padding
            Cipher c = Cipher.getInstance(
                String.format("%s/%s/%s",ALGORITHM_NAME,MODE_OF_OPERATION,PADDING_SCHEME)
            );

            // Get encrypted bytes
            byte [] encryptedBytes = new byte[ivPlusEncryptedBytes.length - IV_SIZE];
            System.arraycopy(ivPlusEncryptedBytes, IV_SIZE, encryptedBytes, 0, encryptedBytes.length);

            // Init for decryption
            c.init(Cipher.DECRYPT_MODE, secretKey, spec, secureRandom);

            // Add AAD tag data if present
            aad.ifPresent(t -> {
                try {
                    c.updateAAD(t.getBytes("UTF-8"));
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            });

            // Add message to decrypt
            c.update(encryptedBytes);

            // Decrypt
            byte[] decryptedBytes
                = c.doFinal();

            // Return
            return new String(decryptedBytes, "UTF-8");

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

摘要

加密并不容易。 简单的示例将为您的应用程序带来带有安全漏洞的实现。 如果您需要单密钥对称加密算法，请使用具有256位密钥和96位IV的密码AES / GCM / PKCS5Padding。

参考文献

翻译自: https://www.javacodegeeks.com/2017/12/choosing-java-cryptographic-algorithms-part-2-single-key-symmetric-encryption.html

dnc8371
关注
java实现hash算法
zhenghuishengq的博客
11-05 451
package sanguigu.shujujiegou; import java.util.Scanner; public class HashTableQaq { public static void main(String Args[]){ int data = 7; //创建一个hash表 Hashtable hashtable = new Hashtable(data); String key = "";
java加密算法分享(rsa解密、对称加密、md5加密)
09-04
总结来说，Java加密算法中，RSA提供了一种安全的非对称加密机制，适用于密钥交换和数字签名；对称加密（如AES）则适合大量数据的快速加解密；而MD5则常用于数据校验和密码存储。在实际开发中，根据具体需求选择合适...
java散列_如何在Java中散列密码？
weixin_42365586的博客
02-20 108
实际上，您可以使用内置到Java运行时的工具来完成此操作。Java 6中的SunJCE支持PBKDF 2，这是一个很好的密码哈希算法。byte[]salt=newbyte[16];random.nextBytes(salt);KeySpecspec=newPBEKeySpec("password".toCharArray(),salt,65536,128);SecretKey...
JAVA HASH算法
热门推荐
zeng622peng的专栏
11-26 1万+
<br />/**<br />* Hash算法大全<br><br />* 推荐使用FNV1算法<br />* @algorithm None<br />* @author Goodzzp 2006-11-20<br />* @lastEdit Goodzzp 2006-11-20<br />* @editDetail Create<br />*/<br />public class HashAlgorithms<br />{<br />    /**//**<br />    * 加法hash<br /> 
Java实现的hash算法实现大全，供大家参考
shuangchen的专栏
01-29 1473
/** * Hash算法大全 * 推荐使用FNV1算法 * @algorithm None * @author Goodzzp 2006-11-20 * @lastEdit Goodzzp 2006-11-20  * @editDetail Create */  public class
java Hash算法大全
阅微草堂
03-18 601
Java代码 /** * Hash算法大全 * 推荐使用FNV1算法 * @algorithm None * @author Goodzzp 2006-11-20 * @lastEdit Goodzzp 2006-11-20 * @editDetail Create */ public class HashAlgorithms { /**//** * 加法hash
Java对称加密算法DES实例详解
08-25
Java对称加密算法是使用对称密钥进行加密和解密的加密算法，其加密和解密使用相同的密钥。Java中对称加密算法有多种，而DES（Data Encryption Standard）是其中一种古老的对称加密算法。 一、DES算法概述 DES是一...
Rsa.rar_RSA 算法_java 非对称 加密 算法_rsa java
09-19
在实际应用中，我们还需要考虑密钥的存储和传输安全，以及可能的性能问题，比如对于大数据量的加密，RSA可能不适用，此时可以采用混合加密方案，将RSA用于密钥交换，然后用对称加密算法如AES来处理大量数据。...
密码学实验_对称加密算法DES_非对称加密算法RSA.pdf
02-20
DES是一种广泛使用的对称加密算法，它基于Feistel结构，以64位的数据块和64位的密钥进行操作。实验步骤如下： 1. **明文处理**：首先，从文件中读取明文，将其转换为ASCII码，再转换为比特流。每64位分为一组，不足...
【Java编码准则】の ＃13使用散列函数保存密码
ASCE1885
06-21 2294
明文保存密码的程序在很多方面容易造成密码的泄漏。虽然用户输入的密码一般时明文形式，但是应用程序必须保证密码不是以明文形式存储的。      限制密码泄漏危险的一个有效的方法是使用散列函数，它使得程序中可以间接的对用户输入的密码和原来的密码进行比较，而不需要保存明文或者对密码进行解密后比较。这个方法使密码泄漏的风险降到最低，同时没有引入其他缺点。 ［加密散列函数］      散列函数产
java密码哈希值_如何在Java中散列密码？
weixin_36143786的博客
02-25 189
小编典典实际上，你可以使用Java运行时内置的工具来执行此操作。Java 6中的SunJCE支持PBKDF2，这是用于密码哈希的一种很好的算法。byte[] salt = new byte[16];random.nextBytes(salt);KeySpec spec = new PBEKeySpec("password".toCharArray(), salt, 65536, 128);Secr...
Java Hash算法
stevenbill的博客
03-13 204
HashMap使用Hash算法，所以在解剖HashMap之间，需要先简单的了解Hash算法，Hash算法一般也成为散列算法，通过散列算法将任意的值转化成固定的长度输出，该输出就是散列值，这是一种压缩映射，也就是，散列值的空间远远小于输入的值空间。 简单的说，hash算法的意义在于提供了一种快速存取数据的方法,它用一种算法建立键值与真实值之间的对应关系,(每一个真实值只能有一个键值,但是一个键...
常见哈希算法以及Hmac算法，BouncyCastle总结
m0_46502752的博客
07-21 2237
常见哈希算法总结（1）什么是哈希算法？哈希算法（Hash)又称摘要算法(Digest),它的作用是:对任意一组输出数据进行计算，得到一个固定长度的输出摘要。哈希算法的目的;为了验证原始数据是否被篡改.哈希算法最重要的特点是：相同的输入一定得到相同的输出；不同的输入大概率得到不同的输出. Java字符串的hashCode（）就是一个哈希算法,它的输入是任意字符串，输出是固定的4字节int整数: （2）哈希碰撞概念：两个不同的输入得到了相同的输出。 碰撞能不能避免？答案是不能。碰撞是一定会
哈希算法（Java版）
最新发布
weixin_52572813的博客
07-10 1881
哈希碰撞是不能避免的，因为输出的字节长度是固定的，String的hashCode()输出是4字节整数，最多只有4294967296种输出，但输入的数据长度是不固定的，有无数种输入。在用户输入原始口令后，系统计算用户输入的原始口令的MD5并与数据库存储的MD5对比，如果一致，说明口令正确，否则，口令错误。因为相同的输入永远会得到相同的输出，因此，如果输入被修改了，得到的输出就会不同。然后我们只需要自己计算一下本地文件的哈希值，再与官网公开的哈希值对比，如果相同，说明文件下载正确，否则，说明文件已被篡改。
java中的hash算法
weixin_33919950的博客
11-14 88
https://blog.csdn.net/yc_game/article/details/67633668 https://blog.csdn.net/majinggogogo/article/details/80260400 https://blog.csdn.net/reggergdsg/article...
【Java -- 算法】Hash 算法
Kevin Learn Android
03-23 1182
HashMap是通过一个Entry的数组实现的。而Entry的结构有三个属性，key，value，next。如果在c中，我们遇到next想到的必然是指针，其实在java这就是个指针。
【Java基础】Hash算法
Coffe_Tang的博客
03-18 475
【Java基础】Hash算法基本概念常见的Hash函数碰撞的解决方案HashMap 的数据结构Hash方法Hash 源码解析总结 基本概念 若结构中存在和关键字K相等的记录，则必定在f(K)的存储位置上。由此，不需比较便可直接取得所查记录。称这个对应关系f为散列函数(Hash function)，按这个事先建立的表为散列表。 对不同的关键字可能得到同一散列地址，即key1≠key2，而f(key1...
JAVA加密算法详解：单钥、消息摘要、Diffie-Hellman与非对称加密
本篇文章主要总结了JAVA加密算法的几种核心实现方法，涵盖了基础概念和关键协议。...这篇文章深入浅出地讲解了JAVA中的加密算法，从单钥到非对称，从基础原理到实际应用，为读者提供了一套全面的加密技术体系概述。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值