Java 密码加密

Question

我正在尝试学习如何使用 Java 进行基于密码的加密。 我在网上找到了几个例子，但在 Stack Overflow 上还没有找到。 这些例子对我来说解释起来有点简单，特别是关于算法选择。 似乎有很多传递字符串来说明要使用什么算法，但很少有文档说明字符串的来源及其含义。 而且似乎不同的算法可能需要 KeySpec 类的不同实现，因此我不确定哪些算法可以使用我正在查看的 PBEKeySpec 类。 此外，所有示例似乎都有点过时，许多示例要求您获取以前不属于 JDK 一部分的旧加密包，甚至需要第三方实现。

有人可以简单介绍一下我需要做什么来实现加密（字符串数据，字符串密码）和解密（字节[]数据，字符串密码）吗？

Answer 1

我会谨慎地在论坛上提供或接受与安全相关的建议......具体细节非常复杂，并且通常很快就会过时。

话虽如此，我认为 Sun 的 Java 加密体系结构 ( JCA）参考指南是一个很好的起点。 查看随附的代码示例 说明基于密码的加密 (PBE)。

顺便说一句，标准 JRE 只为 PBE 提供了几个开箱即用的选项（“PBEWithMD5AndDES”就是其中之一）。 如需更多选择，您需要“强加密包”或一些第三方提供商，例如 Bouncy Castle。 另一种选择是使用 JRE 中提供的哈希和密码算法来实现您自己的 PBE。 您可以通过这种方式使用 SHA-256 和 AES-128 实现 PBE (示例加密/解密方法）。

简单地说，PBE的加密方法可能包括以下步骤：

1. 从用户处获取密码和明文，并将它们转换为字节数组。
2. 生成安全的随机salt。
3. 将盐附加到密码并计算其加密哈希。 重复此操作多次。
4. 使用生成的散列作为初始化向量和/或秘密密钥。
5. 保存盐和生成的密文。

Answer 2

使用 RFC2898 从密码生成密钥。 据我所知，它不包含在 JRE 或 JCE 中，但它包含在 J2EE 服务器中，例如 JBoss、Oracle 和 WebSphere。 它还包含在 .NET 基类库中 ( Rfc2898DeriveBytes）。

Java 中有一些 LGPL 实现，但快速浏览一下 这个 看起来有点过于复杂了。 还有一个很好的 javascript 版本。 （我制作了 修改后的版本 由于缺乏适当许可证的

良好实现，我从 Mattias Gartner 打包了一些代码。 这是完整的代码。 简短、简单、容易理解。 它根据 MS 公共许可证 获得许可。

// PBKDF2.java
// ------------------------------------------------------------------
//
// RFC2898 PBKDF2 in Java.  The RFC2898 defines a standard algorithm for
// deriving key bytes from a text password.  This is sometimes
// abbreviated "PBKDF2", for Password-based key derivation function #2.
//
// There's no RFC2898-compliant PBKDF2 function in the JRE, as far as I
// know, but it is available in many J2EE runtimes, including those from
// JBoss, IBM, and Oracle.
//
// It's fairly simple to implement, so here it is. 
// 
// Created Sun Aug 09 01:06:57 2009
//
// last saved: 
// Time-stamp: <2009-August-09 02:19:50>
// ------------------------------------------------------------------
//
// code thanks to Matthias Gartner
//
// ------------------------------------------------------------------

package cheeso.examples;


import java.security.NoSuchAlgorithmException;
import java.security.InvalidKeyException;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;


public class PBKDF2
{
    public static byte[] deriveKey( byte[] password, byte[] salt, int iterationCount, int dkLen )
        throws java.security.NoSuchAlgorithmException, java.security.InvalidKeyException
    {
        SecretKeySpec keyspec = new SecretKeySpec( password, "HmacSHA1" );
        Mac prf = Mac.getInstance( "HmacSHA1" );
        prf.init( keyspec );

        // Note: hLen, dkLen, l, r, T, F, etc. are horrible names for
        //       variables and functions in this day and age, but they
        //       reflect the terse symbols used in RFC 2898 to describe
        //       the PBKDF2 algorithm, which improves validation of the
        //       code vs. the RFC.
        //
        // dklen is expressed in bytes. (16 for a 128-bit key)

        int hLen = prf.getMacLength();   // 20 for SHA1
        int l = Math.max( dkLen, hLen); //  1 for 128bit (16-byte) keys
        int r = dkLen - (l-1)*hLen;      // 16 for 128bit (16-byte) keys
        byte T[] = new byte[l * hLen];
        int ti_offset = 0;
        for (int i = 1; i <= l; i++) {
            F( T, ti_offset, prf, salt, iterationCount, i );
            ti_offset += hLen;
        }

        if (r < hLen) {
            // Incomplete last block
            byte DK[] = new byte[dkLen];
            System.arraycopy(T, 0, DK, 0, dkLen);
            return DK;
        }
        return T;
    } 


    private static void F( byte[] dest, int offset, Mac prf, byte[] S, int c, int blockIndex ) {
        final int hLen = prf.getMacLength();
        byte U_r[] = new byte[ hLen ];
        // U0 = S || INT (i);
        byte U_i[] = new byte[S.length + 4];
        System.arraycopy( S, 0, U_i, 0, S.length );
        INT( U_i, S.length, blockIndex );
        for( int i = 0; i < c; i++ ) {
            U_i = prf.doFinal( U_i );
            xor( U_r, U_i );
        }

        System.arraycopy( U_r, 0, dest, offset, hLen );
    }

    private static void xor( byte[] dest, byte[] src ) {
        for( int i = 0; i < dest.length; i++ ) {
            dest[i] ^= src[i];
        }
    }

    private static void INT( byte[] dest, int offset, int i ) {
        dest[offset + 0] = (byte) (i / (256 * 256 * 256));
        dest[offset + 1] = (byte) (i / (256 * 256));
        dest[offset + 2] = (byte) (i / (256));
        dest[offset + 3] = (byte) (i);
    } 

    // ctor
    private PBKDF2 () {}

}

Answer 3

在上面 Cheeso 非常有帮助的答案中，存在一个严重的性能错误。

该行

int l = Math.max( dkLen, hLen)

不应该计算最大值，而是计算除法的上限，因此

int l = ((dkLen - 1) / hLen) + 1; // >= ceil(dkLen / hLen), == for dkLen =>1

这将使 16 字节密钥的计算速度加快 20 倍。

Answer 4

您需要一个加密库，它会告诉您如何设置它。
我碰巧喜欢 bouncycastle.org 上的东西。 您可以此处找到他们的操作方法
5.1 示例中提到的 DES 是他们提供的加密之一。 实际字符串的含义取决于提供者。
本质上你加载了库。

Security.addProvider(new BouncyCastleProvider());

然后，仅使用 JCE 接口来完成您想要的任何操作：

 keyGen = KeyGenerator.getInstance("DES", "BC");

Java 会为您处理库和接口的绑定，您不必这样做。
如果您有任何疑问，我很乐意解释更多。 不幸的是，目前我患有“我不记得我是如何学会的”疾病，所以请随时询问。

Answer 5

您可以使用哈希算法（必要时多次）从密码短语中获取一些可用作密钥的原始数据（如果算法需要初始化向量，则还可以使用初始化向量）。

然后，您可以将该密钥与任何对称算法一起使用 - 例如 3DES-CBC 或 AES-CBC（DES 目前被认为已过时）。

根据您可用的 JCE，您可能可以使用不同的算法，但 AES 可能就是您想要的。 然而，算法的选择以及具体如何使用它在某种程度上是一个宗教问题，并且不建议您尝试使用自己的算法，甚至尝试使用标准算法构建自己的加密方案。 如果你没有研究过它，你几乎肯定会弄错，即使你学过。

如果安全性对您来说非常重要，以至于您正在考虑加密，那么您还应该考虑查看安全工程书籍，例如 Bruce Schneier 的《应用密码学》或 Ross Anderson 的《安全工程》——其中存在很多实施陷阱。 例如，使用密码作为密钥首先并不是一个好主意，因为它本质上减少了密钥的大小。

你也可以看看其他人做过的设计，IETF 有很多，例如：
https://datatracker.ietf。 org/doc/html/draft-mcgrew-aead-aes-cbc-hmac-sha1-00

Answer 6

如果您不需要解密密码，而只是根据密码/密码生成加密密钥，则可以实现 PKCS#5 标准，使用 JCE Cipher 和 MessageDigest 类。