使用硬编码方式处理 salt 绝非好方法。这不仅是因为所有项目开发人员都可以使用通过硬编码方式处理的 salt，而且还会使解决这一问题变得极其困难。在代码投入使用之后，无法轻易更改该 salt。如果攻击者知道该 salt 的值，他们就可以计算出该应用程序的“彩虹表”，并更轻松地确定散列值。
例 1：下列代码使用了 hardcoded salt：

    ...
    PKCS5_PBKDF2_HMAC(pass, strlen(pass), "2!@$(5#@532@%#$253l5#@$", 2, ITERATION, EVP_sha512(), outputBytes, digest);
    ...

此代码将成功运行，但有权访问此代码的任何人都可以访问 salt。一旦程序发布，可能无法更改名为“2!@$(5#@532@%#$253l5#@$”的 salt。雇员可以利用手中掌握的信息访问权限入侵系统。

采用硬编码处理 salt 绝非一个好方法。对 salt 进行硬编码会使任何有权访问源的人都可以使用它，从而破坏该函数的加密强度。如果攻击者知道 salt 的值，他们就可以计算出该应用程序的“彩虹表”，并更轻松地确定散列值。
示例 1：下列代码使用了 hardcoded salt：

...
const salt = "some constant value";
crypto.pbkdf2(
    password,
    salt,
    iterations,
    keyLength,
    "sha256",
    function (err, derivedKey) { ... }
);

此代码将成功运行，但有权访问此代码的任何人都可以访问 salt。一旦程序发布，可能无法更改 salt。心怀不轨的雇员可以利用手中掌握的信息访问权限破坏系统。

使用硬编码方式处理 salt 绝非好方法。这不仅是因为所有项目开发人员都可以使用通过硬编码方式处理的 salt，而且还会使解决这一问题变得极其困难。在代码投入使用之后，无法轻易更改该 salt。如果攻击者知道该 salt 的值，他们就可以计算出该应用程序的“彩虹表”，并更轻松地确定散列值。
例 1：下列代码使用了 hardcoded salt：

...
CCKeyDerivationPBKDF(kCCPBKDF2,
                     password,
                     passwordLen,
                     "2!@$(5#@532@%#$253l5#@$",
                     2,
                     kCCPRFHmacAlgSHA256,
                     100000,
                     derivedKey,
                     derivedKeyLen);
...

此代码将成功运行，但有权访问此代码的任何人都可以访问 salt。一旦程序发布，可能无法更改名为“2!@$(5#@532@%#$253l5#@$”的 salt。雇员可以利用手中掌握的信息访问权限入侵系统。

使用硬编码方式处理 salt 绝非好方法。这不仅是因为所有项目开发人员都可以使用通过硬编码方式处理的 salt，而且还会使解决这一问题变得极其困难。在代码投入使用之后，无法轻易更改该 salt。如果攻击者知道该 salt 的值，他们就可以计算出该应用程序的“彩虹表”，并更轻松地确定散列值。
示例 1：下列代码使用了 hardcoded salt：

...
$hash = hash_pbkdf2('sha256', $password, '2!@$(5#@532@%#$253l5#@$', 100000)
...

此代码将成功运行，但有权访问此代码的任何人都可以访问 salt。一旦程序发布，可能无法更改名为“2!@$(5#@532@%#$253l5#@$”的 salt。雇员可以利用手中掌握的信息访问权限入侵系统。

使用硬编码方式处理 salt 绝非好方法。这不仅是因为所有项目开发人员都可以使用通过硬编码方式处理的 salt，而且还会使解决这一问题变得极其困难。在代码投入使用之后，无法轻易更改该 salt。如果攻击者知道该 salt 的值，他们就可以计算出该应用程序的“彩虹表”，并更轻松地确定散列值。
例 1：下列代码使用了 hardcoded salt：

...
from hashlib import pbkdf2_hmac
dk = pbkdf2_hmac('sha256', password, '2!@$(5#@532@%#$253l5#@$', 100000)
...

此代码将成功运行，但有权访问此代码的任何人都可以访问 salt。一旦程序发布，可能无法更改名为“2!@$(5#@532@%#$253l5#@$”的 salt。雇员可以利用手中掌握的信息访问权限入侵系统。

使用硬编码方式处理 salt 绝非好方法。这不仅是因为所有项目开发人员都可以使用通过硬编码方式处理的 salt，而且还会使解决这一问题变得极其困难。在代码投入使用之后，无法轻易更改该 salt。如果攻击者知道该 salt 的值，他们就可以计算出该应用程序的“彩虹表”，并更轻松地确定散列值。
例 1：下列代码使用了 hardcoded salt：

...
dk = OpenSSL::PKCS5.pbkdf2_hmac(password, '2!@$(5#@532@%#$253l5#@$', 100000, 256, digest)
...

此代码将成功运行，但有权访问此代码的任何人都可以访问 salt。一旦程序发布，可能无法更改名为“2!@$(5#@532@%#$253l5#@$”的 salt。雇员可以利用手中掌握的信息访问权限入侵系统。

使用硬编码方式处理 salt 绝非好方法。这不仅是因为所有项目开发人员都可以使用通过硬编码方式处理的 salt，而且还会使解决这一问题变得极其困难。在代码投入使用之后，无法轻易更改该 salt。如果攻击者知道该 salt 的值，他们就可以计算出该应用程序的“彩虹表”，并更轻松地确定散列值。
示例 1：以下代码使用了 hardcoded salt：

...
let ITERATION = UInt32(100000)
let salt = "2!@$(5#@532@%#$253l5#@$"
...
CCKeyDerivationPBKDF(CCPBKDFAlgorithm(kCCPBKDF2),
password,
passwordLength,
salt,
salt.lengthOfBytesUsingEncoding(NSUTF8StringEncoding),
CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA256),
ITERATION,
derivedKey,
derivedKeyLength)
...

此代码将成功运行，但有权访问此代码的任何人都可以访问 salt。一旦程序发布，可能无法更改名为“2!@$(5#@532@%#$253l5#@$”的 salt。雇员可以利用手中掌握的信息访问权限入侵系统。

使用硬编码方式处理 salt 绝非好方法。这不仅是因为所有项目开发人员都可以使用通过硬编码方式处理的 salt，而且还会使解决这一问题变得极其困难。在代码投入使用之后，无法轻易更改该 salt。如果攻击者知道该 salt 的值，他们就可以计算出该应用程序的“彩虹表”，并更轻松地确定散列值。
例 1：下列代码使用了 hardcoded salt：

    ...
    crypt(password, "2!@$(5#@532@%#$253l5#@$");
    ...

此代码将成功运行，但有权访问此代码的任何人都可以访问 salt。一旦程序发布，可能无法更改名为“2!@$(5#@532@%#$253l5#@$”的 salt。雇员可以利用手中掌握的信息访问权限入侵系统。

采用硬编码处理 salt 绝非一个好方法。这不仅是因为所有项目开发人员都可以使用 hardcoded salt 来查看该 salt，而且还会使解决这一问题变得极其困难。一旦该代码投入使用，则无法轻易更改该 salt。如果攻击者知道 salt 的值，他们就可以计算出该应用程序的“彩虹表”，并轻松地确定散列值。
示例 1：下列代码使用了 hardcoded salt：

    ...
    salt := "2!@$(5#@532@%#$253l5#@$"
    password := get_password()
    sha256.Sum256([]byte(salt + password)
    ...

此代码成功运行，但有权访问此代码的任何人都可以访问 salt。一旦程序发布，将无法更改名为“2!@$(5#@532@%#$253l5#@$”的 salt。雇员可以利用手中掌握的信息访问权限入侵系统。

使用硬编码方式处理 salt 绝非好方法。这不仅是因为所有项目开发人员都可以使用通过硬编码方式处理的 salt，而且还会使解决这一问题变得极其困难。在代码投入使用之后，无法轻易更改该 salt。如果攻击者知道该 salt 的值，他们就可以计算出该应用程序的“彩虹表”，并更轻松地确定散列值。
例 1：下列代码使用了 hardcoded salt：

    ...
    crypt($password, '2!@$(5#@532@%#$253l5#@$');
    ...

此代码将成功运行，但有权访问此代码的任何人都可以访问 salt。一旦程序发布，可能无法更改名为“2!@$(5#@532@%#$253l5#@$”的 salt。雇员可以利用手中掌握的信息访问权限入侵系统。

使用硬编码方式处理 salt 绝非好方法。这不仅是因为所有项目开发人员都可以使用通过硬编码方式处理的 salt，而且还会使解决这一问题变得极其困难。在代码投入使用之后，无法轻易更改该 salt。如果攻击者知道该 salt 的值，他们就可以计算出该应用程序的“彩虹表”，并更轻松地确定散列值。
例 1：下列代码使用了 hardcoded salt：

    ...
    from django.contrib.auth.hashers import make_password
    make_password(password, salt="2!@$(5#@532@%#$253l5#@$")
    ...

此代码将成功运行，但有权访问此代码的任何人都可以访问 salt。一旦程序发布，可能无法更改名为“2!@$(5#@532@%#$253l5#@$”的 salt。雇员可以利用手中掌握的信息访问权限入侵系统。

使用硬编码方式处理 salt 绝非好方法。这不仅是因为所有项目开发人员都可以使用通过硬编码方式处理的 salt，而且还会使解决这一问题变得极其困难。在代码投入使用之后，无法轻易更改该 salt。如果攻击者知道该 salt 的值，他们就可以计算出该应用程序的“彩虹表”，并更轻松地确定散列值。
示例 1：以下代码使用了用于密码散列的 hardcoded salt：

require 'openssl'
...
password = get_password()
salt = '2!@$(5#@532@%#$253l5#@$'
hash = OpenSSL::Digest::SHA256.digest(salt + password)
...

此代码将成功运行，但有权访问此代码的任何人都可以访问 salt。一旦程序发布，可能无法更改名为“2!@$(5#@532@%#$253l5#@$”的 salt。雇员可以利用手中掌握的信息访问权限入侵系统。

salt 值应使用加密伪随机数值生成器来创建。如果不使用随机 salt 值，则结果散列或 HMAC 的可预测性会高得多，也更容易受到字典式攻击。

示例 1：以下代码重新使用密码作为 salt：

...
let password = getPassword();
let salt = password;
crypto.pbkdf2(
    password,
    salt,
    iterations,
    keyLength,
    "sha256",
    function (err, derivedKey) { ... }
);

salt 值应使用加密伪随机数值生成器来创建。如果不使用随机 salt 值，则结果散列或 HMAC 的可预测性会高得多，也更容易受到字典式攻击。

示例 1：以下代码重新使用密码作为 salt：

function register(){
  $password = $_GET['password'];
  $username = $_GET['username'];

  $hash = hash_pbkdf2('sha256', $password, $password, 100000);
...

salt 值应使用加密伪随机数值生成器来创建。如果不使用随机 salt 值，则结果散列或 HMAC 的可预测性会高得多，也更容易受到字典式攻击。

例 1：以下代码重新使用密码作为 salt：

import hashlib, binascii

def register(request):
  password = request.GET['password']
  username = request.GET['username']

  dk = hashlib.pbkdf2_hmac('sha256', password, password, 100000)
  hash = binascii.hexlify(dk)
  store(username, hash)
...

salt 值应使用加密伪随机数值生成器来创建。如果不使用随机 salt 值，则结果散列或 HMAC 的可预测性会高得多，也更容易受到字典式攻击。

例 1：以下代码重新使用密码作为 salt：

require 'openssl'
...
req = Rack::Response.new
password = req.params['password']
...
key = OpenSSL::PKCS5::pbkdf2_hmac(password, password, 100000, 256, 'SHA256')
...

弱加密散列值：用户控制 PBE Salt 问题将在以下情况下出现：

1. 数据通过一个不可信赖的数据源进入程序。

2. 用户控制的数据包括在 salt 中，或完全作为基于密码的密钥派生函数中的 salt 使用。


如同许多软件安全漏洞一样，弱加密散列值：用户控制 PBE Salt 只是通向终端的一个途径，它本身并不是终端。从本质上看，这些漏洞是显而易见的：攻击者可将恶意数据传递到应用程序，然后这些数据被用作 PBKDF 中的全部或部分 salt。

使用用户定义的 salt 的问题在于，它可以实现各种不同的攻击：

1. 攻击者可以利用这一漏洞，指定一个空 salt 作为自己的密码。由此，可以轻易地使用许多不同的散列快速地对其密码执行派生，以泄露有关您的应用程序中使用的 PBKDF 实现的信息。这样，通过限制所用散列的特定变体，可以更轻松地“破解”其他密码。
2. 如果攻击者能够操纵其他用户的 salt，或者诱骗其他用户使用空 salt，这将使他们能够计算应用程序的“彩虹表”，并更轻松地确定派生值。

示例 1：以下代码使用了用户控制 salt：

  string salt = ConfigurationManager.AppSettings["salt"];
  ...
  Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes("password", Encoding.ASCII.GetBytes(salt));
  ...
  

Example 1 中的代码将成功运行，但任何有权使用此功能的人将能够通过修改 salt 属性来操纵用于派生密钥或密码的 salt。一旦程序发布，撤消与用户控制的 salt 相关的问题就会非常困难，因为很难知道恶意用户是否确定了密码散列的 salt。

在以下情况下会发生 Weak Cryptographic Hash:用户控制 PBE 的 Salt 问题将在以下情况下出现：

1. 数据通过一个不可信赖的数据源进入程序

2. 用户控制的数据包括在 salt 中，或完全作为基于密码的密钥派生函数中的 salt 使用。


如同许多软件安全漏洞一样，Weak Cryptographic Hash:用户控制 PBE 的 Salt 是到达终点的一个途径，其本身并不是终点。从本质上看，这些漏洞是显而易见的：攻击者可将恶意数据传递到应用程序，然后这些数据被用作 PSKDF 中的全部或部分 salt。

用户控制 salt 的问题在于，它可以实现几个不同的攻击：

1. 攻击者可以利用这一漏洞，指定一个空 salt 作为自己的密码。由此，可以轻易地使用许多不同的散列快速地对其密码执行派生，以泄露有关您的应用程序中使用的 PBKDF 实现的信息。这样，通过限制所用散列的特定变体，可以更轻松地“破解”其他密码。
2. 如果攻击者能够操纵其他用户的 salt，或者诱骗其他用户使用空 salt，这将使他们能够计算应用程序的“彩虹表”，并更轻松地确定派生值。

例 1： 以下代码使用用户控制 salt：

    ...
    salt = getenv("SALT");
    PKCS5_PBKDF2_HMAC(pass, sizeof(pass), salt, sizeof(salt), ITERATION, EVP_sha512(), outputBytes, digest);
    ...

Example 1 中的代码将成功运行，但任何有权使用此功能的人将能够通过修改环境变量 SALT 来操纵用于派生密钥或密码的 salt。一旦程序发布，撤消与用户控制的 salt 相关的问题就会非常困难，因为很难知道恶意用户是否确定了密码散列的 salt。

在以下情况下会发生 Weak Cryptographic Hash: 用户控制的 PBE salt 问题将在以下情况下出现：

1.数据通过一个不可信赖的数据源进入程序

2.用户控制的数据包括在 salt 中，或完全作为基于密码的密钥派生函数 (PBKDF) 中的 salt 使用。


如同许多软件安全漏洞一样，Weak Cryptographic Hash: 用户控制的 PBE salt 是到达终点的一个途径，其本身并不是终点。从本质上看，这些漏洞是显而易见的：攻击者可将恶意数据传递到应用程序，然后这些数据被用作 PSKDF 中的全部或部分 salt。

使用用户定义的 salt 的问题在于，它可以实现各种不同的攻击：

1.攻击者可以利用这一漏洞，指定一个空 salt 作为自己的密码。由此，可以轻易地使用许多不同的散列快速地对其密码执行派生，以泄露有关您的应用程序中使用的 PBKDF 实现的信息。这样，通过限制所用散列的特定变体，可以更轻松地“破解”其他密码。
2.如果攻击者能够操纵其他用户的 salt，或者诱骗其他用户使用空 salt，这将使他们能够计算应用程序的“彩虹表”，并更轻松地确定派生值。

示例 1：以下代码会使用用户控制的 salt：

app.get('/pbkdf2', function(req, res) {
    ...
    let salt = req.params['salt'];
    crypto.pbkdf2(
        password,
        salt,
        iterations,
        keyLength,
        "sha256",
        function (err, derivedKey) { ... }
    );
}

Example 1 中的代码将成功运行，但任何有权使用此功能的人将能够通过修改 salt 属性来操纵用于派生密钥或密码的 salt。一旦程序发布，撤消与用户控制的 salt 相关的问题就会非常困难，因为很难知道恶意用户是否确定了密码散列的 salt。

弱加密散列值：用户控制 PBE Salt 问题将在以下情况下出现：

1. 数据通过一个不可信赖的数据源进入程序

2. 用户控制的数据包括在 salt 中，或完全作为基于密码的密钥派生函数中的 salt 使用。


如同许多软件安全漏洞一样，弱加密散列值：用户控制 PBE Salt 只是通向终端的一个途径，它本身并不是终端。从本质上看，这些漏洞是显而易见的：攻击者可将恶意数据传递到应用程序，然后这些数据被用作 PBKDF 中的全部或部分 salt。

使用用户定义的 salt 的问题在于，它可以实现各种不同的攻击：

1. 攻击者可以利用这一漏洞，指定一个空 salt 作为自己的密码。由此，可以轻易地使用许多不同的散列快速地对其密码执行派生，以泄露有关您的应用程序中使用的 PBKDF 实现的信息。这样，通过限制所用散列的特定变体，可以更轻松地“破解”其他密码。
2. 如果攻击者能够操纵其他用户的 salt，或者诱骗其他用户使用空 salt，这将使他们能够计算应用程序的“彩虹表”，并更轻松地确定派生值。

示例 1：以下代码会使用用户控制的 salt：

...
@property (strong, nonatomic) IBOutlet UITextField *inputTextField;
...
NSString *salt = _inputTextField.text;
const char *salt_cstr = [salt cStringUsingEncoding:NSUTF8StringEncoding];
...
CCKeyDerivationPBKDF(kCCPBKDF2,
                     password,
                     passwordLen,
                     salt_cstr,
                     salt.length,
                     kCCPRFHmacAlgSHA256,
                     100000,
                     derivedKey,
                     derivedKeyLen);
...

Example 1 中的代码将成功运行，但任何有权使用此功能的人将能够通过修改 UITextField inputTextField 中的文本来操纵用于派生密钥或密码的 salt。一旦程序发布，撤消与用户控制的 salt 相关的问题就会非常困难，因为很难知道恶意用户是否确定了密码散列的 salt。

在以下情况下会发生 Weak Cryptographic Hash: 用户控制 PBE 的 Salt 问题将在以下情况下出现：

1.数据通过一个不可信赖的数据源进入程序。

2.用户控制的数据包括在 salt 中，或完全作为基于密码的密钥派生函数 (PBKDF) 中的 salt 使用。


如同许多软件安全漏洞一样，Weak Cryptographic Hash: 用户控制 PBE 的 Salt 是到达终点的一个途径，其本身并不是终点。从本质上看，这些漏洞是显而易见的：攻击者可将恶意数据传递到应用程序，然后这些数据被用作 PBKDF 中的全部或部分 salt。

使用用户定义的 salt 的问题在于，它可以实现各种不同的攻击：

1.攻击者可以利用这一漏洞，指定一个空 salt 作为自己的密码。由此，可以轻易地使用许多不同的散列快速地对其密码执行派生，以泄露有关您的应用程序中使用的 PBKDF 实现的信息。这样，通过限制所用散列的特定变体，可以更轻松地“破解”其他密码。
2.如果攻击者能够操纵其他用户的 salt，或者诱骗其他用户使用空 salt，这将使他们能够计算应用程序的“彩虹表”，并更轻松地确定派生值。

示例 1：以下代码使用用户控制 salt：

function register(){
  $password = $_GET['password'];
  $username = $_GET['username'];
  $salt = getenv('SALT');

  $hash = hash_pbkdf2('sha256', $password, $salt, 100000);
...

Example 1 中的代码将成功运行，但任何有权使用此功能的人将能够通过修改环境变量 SALT 来操纵用于派生密钥或密码的 salt。一旦程序发布，撤消与用户控制的 salt 相关的问题就会非常困难，因为很难知道恶意用户是否确定了密码散列的 salt。

在以下情况下会发生 Weak Cryptographic Hash:用户控制 PBE 的 Salt 问题将在以下情况下出现：

1. 数据通过一个不可信赖的数据源进入程序。

2. 用户控制的数据包括在 salt 中，或完全作为基于密码的密钥派生函数中的 salt 使用。


如同许多软件安全漏洞一样，Weak Cryptographic Hash:用户控制 PBE 的 Salt 是到达终点的一个途径，其本身并不是终点。从本质上看，这些漏洞是显而易见的：攻击者可将恶意数据传递到应用程序，然后这些数据被用作 PSKDF 中的全部或部分 salt。

使用用户定义的 salt 的问题在于，它可以实现各种不同的攻击：

1. 攻击者可以利用这一漏洞，指定一个空 salt 作为自己的密码。由此，可以轻易地使用许多不同的散列快速地对其密码执行派生，以泄露有关您的应用程序中使用的 PBKDF 实现的信息。这样，通过限制所用散列的特定变体，可以更轻松地“破解”其他密码。
2. 如果攻击者能够操纵其他用户的 salt，或者诱骗其他用户使用空 salt，这将使他们能够计算应用程序的“彩虹表”，并更轻松地确定派生值。

例 1： 以下代码使用用户控制 salt：

import hashlib, binascii

def register(request):
  password = request.GET['password']
  username = request.GET['username']
  salt = os.environ['SALT']

  dk = hashlib.pbkdf2_hmac('sha256', password, salt, 100000)
  hash = binascii.hexlify(dk)
  store(username, hash)
...

Example 1 中的代码将成功运行，但任何有权使用此功能的人将能够通过修改环境变量 SALT 来操纵用于派生密钥或密码的 salt。一旦程序发布，撤消与用户控制的 salt 相关的问题就会非常困难，因为很难知道恶意用户是否确定了密码散列的 salt。

在以下情况下会发生 Weak Cryptographic Hash:用户控制 PBE 的 Salt 问题将在以下情况下出现：

1. 数据通过一个不可信赖的数据源进入程序

2. 用户控制的数据包括在 salt 中，或完全作为基于密码的密钥派生函数中的 salt 使用。


如同许多软件安全漏洞一样，Weak Cryptographic Hash:用户控制 PBE 的 Salt 是到达终点的一个途径，其本身并不是终点。从本质上看，这些漏洞是显而易见的：攻击者可将恶意数据传递到应用程序，然后这些数据被用作 PSKDF 中的全部或部分 salt。

使用用户定义的 salt 的问题在于，它可以实现各种不同的攻击：

1. 攻击者可以利用这一漏洞，指定一个空 salt 作为自己的密码。由此，可以轻易地使用许多不同的散列快速地对其密码执行派生，以泄露有关您的应用程序中使用的 PBKDF 实现的信息。这样，通过限制所用散列的特定变体，可以更轻松地“破解”其他密码。
2. 如果攻击者能够操纵其他用户的 salt，或者诱骗其他用户使用空 salt，这将使他们能够计算应用程序的“彩虹表”，并更轻松地确定派生值。

例 1： 以下代码使用用户控制 salt：

...
salt=io.read
key = OpenSSL::PKCS5::pbkdf2_hmac(pass, salt, iter_count, 256, 'SHA256')
...

Example 1 中的代码将成功运行，但任何有权使用此功能的人将能够通过修改 salt 中的文本来操纵用于派生密钥或密码的 salt。一旦程序发布，撤消与用户控制的 salt 相关的问题就会非常困难，因为很难知道恶意用户是否确定了密码散列的 salt。

弱加密散列值：用户控制 PBE Salt 问题将在以下情况下出现：

1. 数据通过一个不可信赖的数据源进入程序

2. 用户控制的数据包括在 salt 中，或完全作为基于密码的密钥派生函数中的 salt 使用。


如同许多软件安全漏洞一样，弱加密散列值：用户控制 PBE Salt 只是通向终端的一个途径，它本身并不是终端。从本质上看，这些漏洞是显而易见的：攻击者可将恶意数据传递到应用程序，然后这些数据被用作 PBKDF 中的全部或部分 salt。

使用用户定义的 salt 的问题在于，它可以实现各种不同的攻击：

1. 攻击者可以利用这一漏洞，指定一个空 salt 作为自己的密码。由此，可以轻易地使用许多不同的散列快速地对其密码执行派生，以泄露有关您的应用程序中使用的 PBKDF 实现的信息。这样，通过限制所用散列的特定变体，可以更轻松地“破解”其他密码。
2. 如果攻击者能够操纵其他用户的 salt，或者诱骗其他用户使用空 salt，这将使他们能够计算应用程序的“彩虹表”，并更轻松地确定派生值。

示例 1：以下代码会使用用户控制的 salt：

...
@IBOutlet weak var inputTextField : UITextField!
...
let salt = (inputTextField.text as NSString).dataUsingEncoding(NSUTF8StringEncoding)
let saltPointer = UnsafePointer<UInt8>(salt.bytes)
let saltLength = size_t(salt.length)
...
let algorithm : CCPBKDFAlgorithm = CCPBKDFAlgorithm(kCCPBKDF2)
let prf : CCPseudoRandomAlgorithm = CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA256)
CCKeyDerivationPBKDF(algorithm,
                     passwordPointer,
                     passwordLength,
                     saltPointer,
                     saltLength,
                     prf,
                     100000,
                     derivedKeyPointer,
                     derivedKeyLength)
...

Example 1 中的代码将成功运行，但任何有权使用此功能的人将能够通过修改 UITextField inputTextField 中的文本来操纵用于派生密钥或密码的 salt。一旦程序发布，撤消与用户控制的 salt 相关的问题就会非常困难，因为很难知道恶意用户是否确定了密码散列的 salt。

在以下情况下会发生 Weak Cryptographic Hash:用户控制 salt 问题将在以下情况下出现：

1. 数据通过一个不可信赖的数据源进入程序

2. 用户控制的数据包括在 salt 中，或完全用作加密散列函数中的 salt。

如同许多软件安全漏洞一样，Weak Cryptographic Hash:用户控制 Salt 是到达终点的一个途径，其本身并不是终点。从本质上看，这些漏洞是显而易见的：攻击者可将恶意数据传递到应用程序，然后这些数据被用作加密散列中的全部或部分 salt。

用户控制 salt 的问题在于，它可以实现几个不同的攻击：

1. 攻击者可以利用这一漏洞，为被散列的数据指定一个空 salt。由此，可以轻易地使用许多不同的散列算法控制被散列的数据，以泄露有关您的应用程序中使用的散列实现的信息。这样，通过限制所用散列的特定变体，可以更轻松地“破解”其他密码。
2. 如果攻击者能够操纵其他用户的 salt，或者诱骗其他用户使用空 salt，这将使他们能够计算应用程序的“彩虹表”，并更轻松地确定哈希值。

例 1： 以下代码使用用户控制 salt 进行密码散列：

    ...
    salt = getenv("SALT");
    password = crypt(getpass("Password:"), salt);
    ...

Example 1 将成功运行，但任何有权使用此功能的人将能够通过修改环境变量 SALT 来操纵用于对密码执行散列的 salt。此外，此代码还使用了 crypt() 函数，该函数不应用于对密码执行加密散列。一旦程序发布，撤消与用户控制的 salt 相关的问题就会非常困难，因为很难知道恶意用户是否确定了密码散列的 salt。

在以下情况下会发生 Weak Cryptographic Hash: 用户控制 salt 问题将在以下情况下出现：

1.数据通过一个不可信赖的数据源进入程序。

2.用户控制的数据包括在 salt 中，或完全用作加密散列函数中的 salt。


如同许多软件安全漏洞一样，Weak Cryptographic Hash: 用户控制 Salt 是到达终点的一个途径，其本身并不是终点。从本质上看，这些漏洞是显而易见的：攻击者可将恶意数据传递到应用程序，然后这些数据被用作加密散列函数中的全部或部分 salt。

用户定义的 salt 可以实现各种不同的攻击：

1.攻击者可以利用这一漏洞，指定一个空 salt 作为散列数据。然后攻击者可以使用许多不同的散列算法快速控制数据，以泄露有关您的应用程序中使用的散列实现的信息。这样，通过限制所用散列的特定变体，可以更轻松地“破解”其他数据值。
2.如果攻击者可以操纵其他用户的 salt，或者诱骗其他用户使用空 salt，这使他们能够计算应用程序的“彩虹表”，并轻松地确定散列值。

示例 1：以下代码使用用户控制 salt 进行密码散列：

func someHandler(w http.ResponseWriter, r *http.Request){
  r.parseForm()
  salt := r.FormValue("salt")
  password := r.FormValue("password")
  ...
  sha256.Sum256([]byte(salt + password))
}

Example 1 中的代码将成功运行，但任何有权使用此功能的人可以通过修改 salt 环境变量来操纵用于对密码执行散列的 salt。此外，此代码还会使用 Sum256 加密散列函数，而该函数不应该用于对密码执行加密散列。一旦程序发布，撤消与用户控制的 salt 相关的问题就会非常困难，因为很难知道恶意用户是否确定了密码散列的 salt。

在以下情况下会发生 Weak Cryptographic Hash:用户控制 salt 问题将在以下情况下出现：

1. 数据通过一个不可信赖的数据源进入程序。

2. 用户控制的数据包括在 salt 中，或完全用作加密散列函数中的 salt。


如同许多软件安全漏洞一样，Weak Cryptographic Hash:用户控制 Salt 是到达终点的一个途径，其本身并不是终点。从本质上看，这些漏洞是显而易见的：攻击者可将恶意数据传递到应用程序，然后这些数据被用作加密散列函数中的全部或部分 salt。

使用用户定义的 salt 的问题在于，它可以实现各种不同的攻击：

1. 攻击者可以利用这一漏洞，为被散列的数据指定一个空 salt。由此，可以轻易地使用许多不同的散列算法控制被散列的数据，以泄露有关您的应用程序中使用的散列实现的信息。这样，通过限制所用散列的特定变体，可以更轻松地“破解”其他密码。
2. 如果攻击者能够操纵其他用户的 salt，或者诱骗其他用户使用空 salt，这将使他们能够计算应用程序的“彩虹表”，并更轻松地确定哈希值。

例 1： 以下代码使用用户控制 salt 进行密码散列：

import hashlib, binascii

def register(request):
  password = request.GET['password']
  username = request.GET['username']
  salt = os.environ['SALT']

  hash = hashlib.md5("%s:%s" % (salt, password,)).hexdigest()
  store(username, hash)
...

Example 1 中的代码将成功运行，但任何有权使用此功能的人将能够通过修改 SALT 环境变量来操纵用于对密码执行散列的 salt。此外，此代码还会使用 md5() 加密散列函数，而该函数不应该用于对密码执行加密散列。一旦程序发布，撤消与用户控制的 salt 相关的问题就会非常困难，因为很难知道恶意用户是否确定了密码散列的 salt。

在以下情况下会发生 Weak Cryptographic Hash:用户控制 salt 问题将在以下情况下出现：

1. 数据通过一个不可信赖的数据源进入程序

2. 用户控制的数据包括在 salt 中，或完全用作加密散列函数中的 salt。

如同许多软件安全漏洞一样，Weak Cryptographic Hash:用户控制 Salt 是到达终点的一个途径，其本身并不是终点。从本质上看，这些漏洞是显而易见的：攻击者可将恶意数据传递到应用程序，该数据随后用作加密散列中的 salt。

使用用户定义的 salt 的问题在于，它可以实现各种不同的攻击：

1. 攻击者可以利用这一漏洞，为被散列的数据指定一个空 salt。由此，可以轻易地使用许多不同的散列算法控制被散列的数据，以泄露有关您的应用程序中使用的散列实现的信息。这样，通过限制所用散列的特定变体，可以更轻松地“破解”其他密码。
2. 如果攻击者能够操纵其他用户的 salt，或者诱骗其他用户使用空 salt，这将使他们能够计算应用程序的“彩虹表”，并更轻松地确定哈希值。

例 1： 以下代码使用用户控制 salt 进行密码散列：

    ...
    salt = req.params['salt']
    hash = @userPassword.crypt(salt)
    ...

Example 1 中的代码将成功运行，但任何有权使用此功能的人将能够通过修改 salt 参数来操纵用于对密码执行散列的 salt。此外，此代码还使用了 String#crypt() 函数，该函数不应用于对密码执行加密散列。一旦程序发布，撤消与用户控制的 salt 相关的问题就会非常困难，因为很难知道恶意用户是否确定了密码散列的 salt。

在以下情况下会发生 Weak Cryptographic Hash: 用户控制 salt 问题将在以下情况下出现：

1.数据通过一个不可信赖的数据源进入程序。

2.用户控制的数据包括在 salt 中，或完全用作加密散列函数中的 salt。


如同许多软件安全漏洞一样，Weak Cryptographic Hash: 用户控制 Salt 是到达终点的一个途径，其本身并不是终点。利用这种漏洞，攻击者可将恶意数据传递到应用程序，然后这些数据被用作加密散列函数中的全部或部分 salt。

用户定义的 salt 可以实现各种不同的攻击：

1.攻击者可以利用这一漏洞，指定一个空 salt 作为散列数据。然后攻击者可以使用许多不同的散列算法快速对受其控制的数据进行散列操作，以泄露有关您的应用程序中使用的散列实现的信息。这样，通过限制所用散列的特定变体，可以更轻松地“破解”其他数据值。
2.如果攻击者可以操纵其他用户的 salt，或者诱骗其他用户使用空 salt，这使他们能够计算应用程序的“彩虹表”，并轻松地确定散列值。

示例 1：以下代码使用用户控制的 salt 来派生加密密钥：

let saltData = userInput.data(using: .utf8)

sharedSecret.hkdfDerivedSymmetricKey(
    using: SHA256.self,
    salt: saltData,
    sharedInfo: info,
    outputByteCount: 1000
)

示例 1 中的代码将成功运行，但任何有权使用此功能的人可以通过修改 userInput 的值来操纵用于派生加密密钥的 salt。一旦程序发布，撤消与用户控制的 salt 相关的问题就会非常困难，因为很难知道恶意用户是否确定了密码散列的 salt。