java - 处理源代码中用于身份验证的密码

Question

假设我正在尝试从使用基本身份验证/基本证书的 RESTful api 中提取，那么在我的程序中存储该用户名和密码的最佳方式是什么？现在它只是以纯文本形式存在。

UsernamePasswordCredentials creds = new UsernamePasswordCredentials("myName@myserver","myPassword1234");

有没有一些更安全的方法？

谢谢

Answer 1

---

重要的提示：

如果您将身份验证系统作为一个整体进行设计，则不应存储密码，即使密码已加密。您存储一个哈希，并检查登录期间提供的密码是否与相同的哈希匹配。这样，您的数据库上的安全漏洞就可以避免暴露您的用户密码。

话虽如此，对于您要按原样存储数据（在本例中为密码）的情况，然后以从内到外的心态，以下是保护您的流程的一些步骤：

---

第一步，您应该将密码处理从 更改String为character array.

这样做的原因是 aString是一个immutable对象，因此即使对象设置为 ; 它的数据也不会立即被清除null；String数据被设置为垃圾收集，这会带来安全问题，因为恶意程序可能会在清理之前访问该（密码）数据。

这就是Swing 的 JPasswordFieldgetText()方法被弃用的主要原因，以及为什么getPassword()使用字符数组。

---

第二步是加密您的凭据，仅在身份验证过程中临时解密它们。或者在服务器端对它们进行散列，存储该散列，然后“忘记”原始密码。

这与第一步类似，可确保您的漏洞时间尽可能小。

建议不要对您的凭据进行硬编码，而是以集中、可配置且易于维护的方式存储它们，例如配置或属性文件或数据库。

您应该在保存文件之前加密您的凭据，此外，您可以对文件本身应用第二次加密（对凭据进行 2 层加密，对其他文件内容进行 1 层加密）。

请注意，上面提到的两个加密过程中的每一个都可以是多层的。作为概念示例，每个加密都可以是三重数据加密标准（AKA TDES 和 3DES）的单独应用。

---

在您的本地环境得到适当保护之后（但请记住，它永远不会“安全”！），第三步是通过使用TLS（传输层安全性）或 SSL（安全套接字层）对您的传输过程应用基本保护。

---

第四步是应用其他保护方法。

例如，对你的“使用”编译应用混淆技术，以避免（即使很快）暴露你的安全措施，以防你的程序被Eve 女士、Mallory 先生或其他人（坏的-伙计们）并反编译。

---

更新 1：

应@Damien.Bell 的要求，这是一个涵盖第一步和第二步的示例：

    //These will be used as the source of the configuration file's stored attributes.
    private static final Map<String, String> COMMON_ATTRIBUTES = new HashMap<String, String>();
    private static final Map<String, char[]> SECURE_ATTRIBUTES = new HashMap<String, char[]>();
    //Ciphering (encryption and decryption) password/key.
    private static final char[] PASSWORD = "Unauthorized_Personel_Is_Unauthorized".toCharArray();
    //Cipher salt.
    private static final byte[] SALT = {
        (byte) 0xde, (byte) 0x33, (byte) 0x10, (byte) 0x12,
        (byte) 0xde, (byte) 0x33, (byte) 0x10, (byte) 0x12,};
    //Desktop dir:
    private static final File DESKTOP = new File(System.getProperty("user.home") + "/Desktop");
    //File names:
    private static final String NO_ENCRYPTION = "no_layers.txt";
    private static final String SINGLE_LAYER = "single_layer.txt";
    private static final String DOUBLE_LAYER = "double_layer.txt";

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws GeneralSecurityException, FileNotFoundException, IOException {
        //Set common attributes.
        COMMON_ATTRIBUTES.put("Gender", "Male");
        COMMON_ATTRIBUTES.put("Age", "21");
        COMMON_ATTRIBUTES.put("Name", "Hypot Hetical");
        COMMON_ATTRIBUTES.put("Nickname", "HH");

        /*
         * Set secure attributes.
         * NOTE: Ignore the use of Strings here, it's being used for convenience only.
         * In real implementations, JPasswordField.getPassword() would send the arrays directly.
         */
        SECURE_ATTRIBUTES.put("Username", "Hypothetical".toCharArray());
        SECURE_ATTRIBUTES.put("Password", "LetMePass_Word".toCharArray());

        /*
         * For demosntration purposes, I make the three encryption layer-levels I mention.
         * To leave no doubt the code works, I use real file IO.
         */
        //File without encryption.
        create_EncryptedFile(NO_ENCRYPTION, COMMON_ATTRIBUTES, SECURE_ATTRIBUTES, 0);
        //File with encryption to secure attributes only.
        create_EncryptedFile(SINGLE_LAYER, COMMON_ATTRIBUTES, SECURE_ATTRIBUTES, 1);
        //File completely encrypted, including re-encryption of secure attributes.
        create_EncryptedFile(DOUBLE_LAYER, COMMON_ATTRIBUTES, SECURE_ATTRIBUTES, 2);

        /*
         * Show contents of all three encryption levels, from file.
         */
        System.out.println("NO ENCRYPTION: \n" + readFile_NoDecryption(NO_ENCRYPTION) + "\n\n\n");
        System.out.println("SINGLE LAYER ENCRYPTION: \n" + readFile_NoDecryption(SINGLE_LAYER) + "\n\n\n");
        System.out.println("DOUBLE LAYER ENCRYPTION: \n" + readFile_NoDecryption(DOUBLE_LAYER) + "\n\n\n");

        /*
         * Decryption is demonstrated with the Double-Layer encryption file.
         */
        //Descrypt first layer. (file content) (REMEMBER: Layers are in reverse order from writing).
        String decryptedContent = readFile_ApplyDecryption(DOUBLE_LAYER);
        System.out.println("READ: [first layer decrypted]\n" + decryptedContent + "\n\n\n");
        //Decrypt second layer (secure data).
        for (String line : decryptedContent.split("\n")) {
            String[] pair = line.split(": ", 2);
            if (pair[0].equalsIgnoreCase("Username") || pair[0].equalsIgnoreCase("Password")) {
                System.out.println("Decrypted: " + pair[0] + ": " + decrypt(pair[1]));
            }
        }
    }

    private static String encrypt(byte[] property) throws GeneralSecurityException {
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
        SecretKey key = keyFactory.generateSecret(new PBEKeySpec(PASSWORD));
        Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
        pbeCipher.init(Cipher.ENCRYPT_MODE, key, new PBEParameterSpec(SALT, 20));

        //Encrypt and save to temporary storage.
        String encrypted = Base64.encodeBytes(pbeCipher.doFinal(property));

        //Cleanup data-sources - Leave no traces behind.
        for (int i = 0; i < property.length; i++) {
            property[i] = 0;
        }
        property = null;
        System.gc();

        //Return encryption result.
        return encrypted;
    }

    private static String encrypt(char[] property) throws GeneralSecurityException {
        //Prepare and encrypt.
        byte[] bytes = new byte[property.length];
        for (int i = 0; i < property.length; i++) {
            bytes[i] = (byte) property[i];
        }
        String encrypted = encrypt(bytes);

        /*
         * Cleanup property here. (child data-source 'bytes' is cleaned inside 'encrypt(byte[])').
         * It's not being done because the sources are being used multiple times for the different layer samples.
         */
//      for (int i = 0; i < property.length; i++) { //cleanup allocated data.
//          property[i] = 0;
//      }
//      property = null; //de-allocate data (set for GC).
//      System.gc(); //Attempt triggering garbage-collection.

        return encrypted;
    }

    private static String encrypt(String property) throws GeneralSecurityException {
        String encrypted = encrypt(property.getBytes());
        /*
         * Strings can't really have their allocated data cleaned before CG,
         * that's why secure data should be handled with char[] or byte[].
         * Still, don't forget to set for GC, even for data of sesser importancy;
         * You are making everything safer still, and freeing up memory as bonus.
         */
        property = null;
        return encrypted;
    }

    private static String decrypt(String property) throws GeneralSecurityException, IOException {
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
        SecretKey key = keyFactory.generateSecret(new PBEKeySpec(PASSWORD));
        Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
        pbeCipher.init(Cipher.DECRYPT_MODE, key, new PBEParameterSpec(SALT, 20));
        return new String(pbeCipher.doFinal(Base64.decode(property)));
    }

    private static void create_EncryptedFile(
                    String fileName,
                    Map<String, String> commonAttributes,
                    Map<String, char[]> secureAttributes,
                    int layers)
                    throws GeneralSecurityException, FileNotFoundException, IOException {
        StringBuilder sb = new StringBuilder();
        for (String k : commonAttributes.keySet()) {
            sb.append(k).append(": ").append(commonAttributes.get(k)).append(System.lineSeparator());
        }
        //First encryption layer. Encrypts secure attribute values only.
        for (String k : secureAttributes.keySet()) {
            String encryptedValue;
            if (layers >= 1) {
                encryptedValue = encrypt(secureAttributes.get(k));
            } else {
                encryptedValue = new String(secureAttributes.get(k));
            }
            sb.append(k).append(": ").append(encryptedValue).append(System.lineSeparator());
        }

        //Prepare file and file-writing process.
        File f = new File(DESKTOP, fileName);
        if (!f.getParentFile().exists()) {
            f.getParentFile().mkdirs();
        } else if (f.exists()) {
            f.delete();
        }
        BufferedWriter bw = new BufferedWriter(new FileWriter(f));
        //Second encryption layer. Encrypts whole file content including previously encrypted stuff.
        if (layers >= 2) {
            bw.append(encrypt(sb.toString().trim()));
        } else {
            bw.append(sb.toString().trim());
        }
        bw.flush();
        bw.close();
    }

    private static String readFile_NoDecryption(String fileName) throws FileNotFoundException, IOException, GeneralSecurityException {
        File f = new File(DESKTOP, fileName);
        BufferedReader br = new BufferedReader(new FileReader(f));
        StringBuilder sb = new StringBuilder();
        while (br.ready()) {
            sb.append(br.readLine()).append(System.lineSeparator());
        }
        return sb.toString();
    }

    private static String readFile_ApplyDecryption(String fileName) throws FileNotFoundException, IOException, GeneralSecurityException {
        File f = new File(DESKTOP, fileName);
        BufferedReader br = new BufferedReader(new FileReader(f));
        StringBuilder sb = new StringBuilder();
        while (br.ready()) {
            sb.append(br.readLine()).append(System.lineSeparator());
        }
        return decrypt(sb.toString());
    }

一个完整的例子，解决每一个保护步骤，将远远超出我认为这个问题的合理性，因为它是关于“步骤是什么”，而不是“如何应用它们”。

它会大大超出我的答案（最后是抽样），而这里关于 SO 的其他问题已经针对这些步骤的“如何”，更合适，并提供更好的解释和抽样每个单独的步骤。

Answer 2

如果您使用的是基本身份验证，则应将其与 SSL 结合使用，以避免以 base64 编码的纯文本形式传递您的凭据。您不想让嗅探您的数据包的人轻松获取您的凭据。此外，不要在源代码中硬编码您的凭据。使它们可配置。从配置文件中读取它们。您应该在将凭据存储到配置文件之前对其进行加密，并且您的应用程序应在从配置文件中读取凭据后解密它们。

Answer 3

1. 初始化请求的安全计算机（您的计算机）。如果那台机器不安全，没有任何东西可以保护你。这是完全独立的主题（最新的软件、正确配置、强密码、加密交换、硬件嗅探器、物理安全等）
2. 保护您的存储您用于存储凭据的介质应该被加密。解密的凭据应该只存储在您的安全机器的 ram 中
3. 维护硬件的人必须被信任（可能是最薄弱的环节）
4. 他们也应该尽可能少地知道。这是对橡胶软管密码分析的保护
5. 您的凭据应满足所有安全建议（适当的长度、随机性、单一用途等）
6. 您与远程服务的连接必须是安全的（SSL 等）
7. 您的远程服务必须是可信的（参见第 1-4 点）。加上它应该容易被黑客入侵（如果您的数据/服务不安全，那么保护您的凭据是没有意义的）。另外它不应该存储您的凭据

加上我可能忘记的一千件事:)

Answer 4

加密凭据通常不是一个好建议。加密的东西可以被解密。常见的最佳实践是将密码存储为加盐哈希。哈希无法解密。添加盐以击败彩虹表的暴力猜测。只要每个 userId 都有自己的随机盐，攻击者就必须为盐的每个可能值生成一组表，从而在整个宇宙的生命周期内迅速使这种攻击变得不可能。这就是为什么如果您忘记了密码，网站通常无法将您的密码发送给您，但他们只能“重置”它。他们没有存储您的密码，只有密码的哈希值。

密码散列不是很难自己实现，但这是一个常见的问题，无数人已经为你解决了。我发现jBcrypt易于使用。

作为防止暴力猜测密码的额外保护，通常的最佳做法是在使用错误密码进行一定次数的登录尝试后强制用户 ID 或远程 IP 等待几秒钟。没有这个，蛮力攻击者每秒可以猜出你的服务器可以处理的尽可能多的密码。每 10 秒猜出 100 个密码或 100 万个密码之间存在巨大差异。

我的印象是您在源代码中包含了用户名/密码组合。这意味着如果您想更改密码，您将不得不重新编译、停止并重新启动您的服务，这也意味着任何掌握您的源代码的人也拥有您的密码。常见的最佳实践是永远不要这样做，而是将凭据（用户名、密码哈希、密码盐）存储在数据存储中

Answer 5

为什么不在源代码中存储凭据

避免在源代码中存储凭据通常是一个好主意。问题是，对代码的访问以及谁应该有权访问凭据通常会随着时间的推移而变化。一旦项目变得更加成熟，通常会有一些开发人员不需要知道，因此不应该知道某些凭据。此外，代码可能会被重用于稍有不同的目的，甚至成为开源代码。此外，随着代码库变得越来越复杂，识别隐藏在代码中间某处的凭据变得非常乏味。

可以肯定地说，数亿用户已经受到硬编码凭据引起的问题的影响。这是一篇带有一些示例的文章。

如何为您的应用提供凭据

如果凭据不是代码的一部分，这会引发如何向应用程序提供凭据的问题。这取决于您的应用程序运行的平台。例如，如果您在某个云服务上托管您的应用程序，该服务将有一种机制以保存方式存储凭据并将它们注入您的应用程序的操作系统环境。为了提供一个具体的例子，这里是如何为 Heroku 上托管的应用程序提供凭据的文档。在您的应用程序代码中，您可以从环境中访问它们。例如，对于 Java，您可以使用getenv

String apiPassword = getenv("API_PASSWORD");

这里API_PASSWORD需要由你的应用程序的托管机制在环境中提供。

延伸阅读

我写了一篇关于该主题的博客文章，更详细地介绍了该主题：将密码保存在源代码之外 - 为什么和如何。

Answer 6

为什么人们在谈论散列。OP 希望存储他的用户凭据以访问外部资源。散列他的密码将无济于事。

现在这已经不成问题了。我只想为每一层提供简单的最佳实践。

1. 将您的密码存储在 java 应用程序中。：将其存储为字符数组。创建一个密码存储类并将密码存储为哈希图，其中键作为您要访问的资源，并将值作为包含用户名和密码的某个对象。使用一些身份验证限制此 api 的入口点 例如：接受登录用户的凭据以验证该用户对该资源的访问级别（只需将用户映射到他们可以访问的密码列表。如果你有很多创建一个组并将密码映射键映射到该组）除此之外存储密码的任何内容都取决于您对 jvm 本身泄漏它的偏执程度。

2. 要传输密码，请确保您在安全的端口上发送密码（例如：Https 好，http 不好）。如果您真的必须通过不安全的协议进行传输，请对其进行加密并将其编码为 base64。确保收件人解码并可以解密您的密码。

Answer 7

如果您无法信任程序运行的环境，但需要通过普通密码或证书进行身份验证，则您无法保护您的凭据。您最多可以使用其他答案中描述的方法来混淆它们。

作为一种解决方法，我将通过您可以信任的代理运行对 RESTful api 的所有请求，并从那里进行明文密码身份验证。