在对安全性要求较高的环境中，使用能够生成可预测值的函数作为随机数据源，会产生 Insecure Randomness 错误。

电脑是一种具有确定性的机器，因此不可能产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性，但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：下面的代码可利用统计学的 PRNG 为购买产品后仍在有效期内的收据创建一个 URL。

FORM GenerateReceiptURL CHANGING baseUrl TYPE string.
    DATA: r TYPE REF TO cl_abap_random,
		  var1 TYPE i,
		  var2 TYPE i,
		  var3 TYPE n.


	GET TIME.
	var1 = sy-uzeit.
	r = cl_abap_random=>create( seed = var1 ).
	r->int31( RECEIVING value = var2 ).
	var3 = var2.
    CONCATENATE baseUrl var3 ".html" INTO baseUrl.
ENDFORM.

这段代码使用 CL_ABAP_RANDOM->INT31 函数为它生成的收据页面生成“唯一”的标识符。由于 CL_ABAP_RANDOM 是统计学的 PRNG，攻击者很容易猜到其生成的字符串。尽管收据系统的底层设计并不完善，但若使用不会生成可预测收据标识符的随机数生成器（如密码学的 PRNG），就会更安全些。

在对安全性要求较高的环境中，使用能够生成可预测值的函数作为随机数据源，会产生 Insecure Randomness 错误。

电脑是一种具有确定性的机器，因此不可能产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性，但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：下面的代码可利用统计学的 PRNG 为购买产品后仍在有效期内的收据创建一个 URL。

string GenerateReceiptURL(string baseUrl) {
    Random Gen = new Random();
    return (baseUrl + Gen.Next().toString() + ".html");
}

这段代码使用 Random.Next() 函数为它生成的收据页面生成“唯一”的标识符。由于 Random.Next() 是统计学的 PRNG，攻击者很容易猜到其生成的字符串。尽管收据系统的底层设计并不完善，但若使用不会生成可预测收据标识符的随机数生成器（如密码学的 PRNG），就会更安全些。

在对安全性要求较高的环境中，使用能产生可预测数值的函数作为随机数据源，会产生 Insecure Randomness 错误。

电脑是一种具有确定性的机器，因此不可能产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性，但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它就很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则可能会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：下面的代码可利用统计学的 PRNG 为购买产品后仍在有效期内的收据创建一个 URL。

char* CreateReceiptURL() {
    int num;
    time_t t1;
    char *URL = (char*) malloc(MAX_URL);
    if (URL) {
        (void) time(&t1);
        srand48((long) t1);     /* use time to set seed */
        sprintf(URL, "%s%d%s", "http://test.com/", lrand48(), ".html");
    }
    return URL;
}

这段代码使用 lrand48() 函数为它生成的收据页面生成“唯一”的标识符。由于 lrand48() 是统计学的 PRNG，攻击者很容易猜到其生成的字符串。尽管收据系统的底层设计并不完善，但若使用不会生成可预测收据标识符的随机数生成器，就会更安全些。

在对安全性要求较高的环境中，使用能够生成可预测值的函数作为随机数据源，会产生 Insecure Randomness 错误。


电脑是一种具有确定性的机器，因此不可能产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性，但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：下面的代码可利用统计学的 PRNG 为购买产品后仍在有效期内的收据创建一个 URL。

<cfoutput>
Receipt: #baseUrl##Rand()#.cfm
</cfoutput>

这段代码使用 Rand() 函数为它生成的收据页面生成“唯一”的标识符。由于 Rand() 是统计学的 PRNG，攻击者很容易猜到其生成的字符串。尽管收据系统的底层设计并不完善，但若使用不会生成可预测收据标识符的随机数生成器（如密码学的 PRNG），就会更安全些。

在对安全性要求较高的环境中，使用能够生成可预测值的函数作为随机性数据源，会产生 Insecure Randomness 错误。

计算机是一种具有确定性的机器，因此无法产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性。但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：以下代码使用统计学的 PRNG 来创建 RSA 密钥。

import "math/rand"
...
var mathRand = rand.New(rand.NewSource(1))
rsa.GenerateKey(mathRand, 2048)

该代码使用 rand.New() 函数生成 RSA 密钥的随机性。由于 rand.New() 是统计学的 PRNG，攻击者很容易猜到其生成的值。

在对安全性要求较高的环境中，使用能够生成可预测值的函数作为随机数据源，会产生 Insecure Randomness 错误。

电脑是一种具有确定性的机器，因此不可能产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性，但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：下面的代码可利用统计学的 PRNG 为购买产品后仍在有效期内的收据创建一个 URL。

function genReceiptURL (baseURL){
  var randNum = Math.random();
  var receiptURL = baseURL + randNum + ".html";
  return receiptURL;
}

这段代码使用 Math.random() 函数为它生成的收据页面生成“唯一”的标识符。由于 Math.random() 是统计学的 PRNG，攻击者很容易猜到其生成的字符串。尽管收据系统的底层设计并不完善，但若使用不会生成可预测收据标识符的随机数生成器（如密码学的 PRNG），就会更安全些。

在对安全性要求较高的环境中，使用能够生成可预测值的函数作为随机性数据源，会产生 Insecure Randomness 错误。

计算机是一种具有确定性的机器，因此无法产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性，但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：下面的代码可利用统计学的 PRNG 为购买产品后仍在有效期内的收据创建一个 URL。

fun GenerateReceiptURL(baseUrl: String): String {
    val ranGen = Random(Date().getTime())
    return baseUrl + ranGen.nextInt(400000000).toString() + ".html"
}

这段代码使用 Random.nextInt() 函数为它所生成的收据页面生成独特的标识符。由于 Random.nextInt() 是统计学的 PRNG，攻击者很容易猜到其生成的字符串。尽管收据系统的底层设计并不完善，但若使用不会生成可预测收据标识符的随机数生成器（如密码学的 PRNG），就会更安全些。

在对安全性要求较高的环境中，使用能够生成可预测值的函数作为随机数据源，会产生 Insecure Randomness 错误。

电脑是一种具有确定性的机器，因此不可能产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性，但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：下面的代码可利用统计学的 PRNG 为购买产品后仍在有效期内的收据创建一个 URL。

  function genReceiptURL($baseURL) {
    $randNum = rand();
    $receiptURL = $baseURL . $randNum . ".html";
    return $receiptURL;
  }

这段代码使用 rand() 函数为它生成的收据页面生成“唯一”的标识符。由于 rand() 是统计学的 PRNG，攻击者很容易猜到其生成的字符串。尽管收据系统的底层设计并不完善，但若使用不会生成可预测收据标识符的随机数生成器（如密码学的 PRNG），就会更安全些。

在对安全性要求较高的环境中，使用能产生可预测数值的函数作为随机数据源，会产生 Insecure Randomness 错误。

电脑是一种具有确定性的机器，因此不可能产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性，但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它就很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则可能会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：下面的代码可利用统计学的 PRNG 为购买产品后仍在有效期内的收据创建一个 URL。

CREATE or REPLACE FUNCTION CREATE_RECEIPT_URL
  RETURN VARCHAR2
AS
  rnum VARCHAR2(48);
  time TIMESTAMP;
  url VARCHAR2(MAX_URL)
BEGIN
  time := SYSTIMESTAMP;
  DBMS_RANDOM.SEED(time);
  rnum := DBMS_RANDOM.STRING('x', 48);
  url := 'http://test.com/' || rnum || '.html';
  RETURN url;
END

这段代码使用 DBMS_RANDOM.SEED() 函数为它生成的收据页面生成“唯一”的标识符。由于 DBMS_RANDOM.SEED() 是统计学的 PRNG，攻击者很容易猜到其生成的字符串。尽管收据系统的底层设计并不完善，但若使用不会生成可预测收据标识符的随机数生成器，就会更安全些。

在对安全性要求较高的环境中，使用能够生成可预测值的函数作为随机数据源，会产生 Insecure Randomness 错误。

电脑是一种具有确定性的机器，因此不可能产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性，但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：下面的代码可利用统计学的 PRNG 为购买产品后仍在有效期内的收据创建一个 URL。

    def genReceiptURL(self,baseURL):
        randNum = random.random()
        receiptURL = baseURL + randNum + ".html"
        return receiptURL

这段代码使用 rand() 函数为它生成的收据页面生成“唯一”的标识符。由于 rand() 是统计学的 PRNG，攻击者很容易猜到其生成的字符串。尽管收据系统的底层设计并不完善，但若使用不会生成可预测收据标识符的随机数生成器（如密码学的 PRNG），就会更安全些。

在对安全性要求较高的环境中，使用能够生成可预测值的函数作为随机数据源，会产生 Insecure Randomness 错误。

电脑是一种具有确定性的机器，因此不可能产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性，但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：下面的代码可利用统计学的 PRNG 为购买产品后仍在有效期内的收据创建一个 URL。

def generateReceiptURL(baseUrl) {
  randNum = rand(400000000)
  return ("#{baseUrl}#{randNum}.html");
}

这段代码使用 Kernel.rand() 函数为它生成的收据页面生成“唯一”的标识符。由于 Kernel.rand() 是统计学的 PRNG，攻击者很容易猜到其生成的字符串。

在对安全性要求较高的环境中，使用能够生成可预测值的函数作为随机数据源，会产生 Insecure Randomness 错误。

电脑是一种具有确定性的机器，因此不可能产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性，但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：下面的代码可利用统计学的 PRNG 为购买产品后仍在有效期内的收据创建一个 URL。

def GenerateReceiptURL(baseUrl : String) : String {
    val ranGen = new scala.util.Random()
    ranGen.setSeed((new Date()).getTime())
    return (baseUrl + ranGen.nextInt(400000000) + ".html")
}

这段代码使用 Random.nextInt() 函数为它生成的收据页面生成“唯一”的标识符。由于 Random.nextInt() 是统计学的 PRNG，攻击者很容易猜到其生成的字符串。尽管收据系统的底层设计并不完善，但若使用不会生成可预测收据标识符的随机数生成器（如密码学的 PRNG），就会更安全些。

在对安全性要求较高的环境中，使用能够生成可预测值的函数作为随机性数据源，会产生 Insecure Randomness 错误。

计算机是一种具有确定性的机器，因此无法产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性，但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它就很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则可能会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：以下代码使用统计学的 PRNG 创建用作重置密码令牌的随机值。

    sqlite3_randomness(10, &reset_token)

在对安全性要求较高的环境中，使用能够生成可预测值的函数作为随机数据源，会产生 Insecure Randomness 错误。

电脑是一种具有确定性的机器，因此不可能产生真正的随机性。伪随机数生成器 (PRNG) 近似于随机算法，始于一个能计算后续数值的种子。

PRNG 包括两种类型：统计学的 PRNG 和密码学的 PRNG。统计学的 PRNG 提供很多有用的统计属性，但其输出结果很容易预测，因此容易复制数值流。在安全性所依赖的生成值不可预测的情况下，这种类型并不适用。密码学的 PRNG 生成的输出结果较难预测，可解决这一问题。为保证值的加密安全性，必须使攻击者根本无法、或几乎不可能鉴别生成的随机值和真正的随机值。通常情况下，如果并未声明 PRNG 算法带有加密保护，那么它很可能就是统计学的 PRNG，因此不应在对安全性要求较高的环境中使用，否则会导致严重的漏洞（如易于猜测的密码、可预测的加密密钥、Session Hijacking 和 DNS Spoofing）。

示例 1：下面的代码可利用统计学的 PRNG 为购买产品后仍在有效期内的收据创建一个 URL。

...
Function genReceiptURL(baseURL)
dim randNum
randNum = Rnd()
genReceiptURL = baseURL & randNum & ".html"
End Function
...

这段代码使用 Rnd() 函数为它生成的收据页面生成“唯一”的标识符。由于 Rnd() 是统计学的 PRNG，攻击者很容易猜到其生成的字符串。尽管收据系统的底层设计并不完善，但若使用不会生成可预测收据标识符的随机数生成器（如密码学的 PRNG），就会更安全些。

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。如果伪随机数值生成器（如 CL_ABAP_RANDOM 类或其变体）使用特定常数值作为种子，则通过 GET_NEXT、INT 和通过可返回或分配值的类似方法返回的值对可以收集大量 PRNG 输出的攻击者来说是可预测的。

示例 1：在以下摘录的代码中，可以通过对象 random_gen1 来预测对象 random_gen2 生成的值。

		DATA: random_gen1 TYPE REF TO cl_abap_random,
			  random_gen2 TYPE REF TO cl_abap_random,
			  var1 TYPE i,
			  var2 TYPE i.

		random_gen1 = cl_abap_random=>create( seed = '1234' ).

		DO 10 TIMES.
			CALL METHOD random_gen1->int
				RECEIVING
			value  = var1.

			WRITE:/ var1.
		ENDDO.

		random_gen2 = cl_abap_random=>create( seed = '1234' ).

		DO 10 TIMES.
			CALL METHOD random_gen2->int
				RECEIVING
			value  = var2.

			WRITE:/ var2.
		ENDDO.

在此示例中，伪随机数值生成器：random_gen1 和 random_gen2 设置了相同的种子，因此 var1 = var2

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。如果伪随机数值生成器（如 rand()）使用特定值作为种子（使用类似 srand(unsigned int) 的函数），则通过 rand() 和通过可返回或分配值的类似方法返回的值对可以收集一定数量 PRNG 输出的攻击者来说是可预测的。

示例 1：伪随机数生成器生成的值在前两个块中是可预测的，因为这两个块以同一种子开始。

        srand(2223333);
        float randomNum = (rand() % 100);
        syslog(LOG_INFO, "Random: %1.2f", randomNum);
        randomNum = (rand() % 100);
        syslog(LOG_INFO, "Random: %1.2f", randomNum);

        srand(2223333);
        float randomNum2 = (rand() % 100);
        syslog(LOG_INFO, "Random: %1.2f", randomNum2);
        randomNum2 = (rand() % 100);
        syslog(LOG_INFO, "Random: %1.2f", randomNum2);

        srand(1231234);
        float randomNum3 = (rand() % 100);
        syslog(LOG_INFO, "Random: %1.2f", randomNum3);
        randomNum3 = (rand() % 100);
        syslog(LOG_INFO, "Random: %1.2f", randomNum3);

在此例子中，randomNum1 和 randomNum2 的结果设置相同的种子，因此在为伪随机数值生成器 srand(2223333) 设置种子的调用后，对 rand() 的每次调用都将会以相同的调用顺序产生相同的输出。例如，输出可能与以下内容相似：

Random: 32.00
Random: 73.00
Random: 32.00
Random: 73.00
Random: 15.00
Random: 75.00

这些结果并不是随机的。

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。如果伪随机数值生成器 (PRNG) 使用特定值作为种子（使用诸如 math.Rand.New(Source) 的函数），则通过 math.Rand.Int() 和通过可返回或分配值的类似方法返回的值对可以收集大量 PRNG 输出的攻击者来说是可预测的。

示例 1：伪随机数生成器生成的值在前两个块中是可预测的，因为这两个块以同一种子开始。

  randomGen := rand.New(rand.NewSource(12345))
  randomInt1 := randomGen.nextInt()
  
  randomGen.Seed(12345)
  randomInt2 := randomGen.nextInt()

在此示例中，PRNG 设置了相同的种子，因此在为伪随机数值生成器 (randomGen.Seed(12345)) 设置种子的调用之后，每次调用 nextInt() 都会产生相同的输出和顺序。

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。如果伪随机数值生成器（如 Random）使用特定值作为种子（使用诸如 Random(Int) 的函数），则通过 Random.nextInt() 和通过可返回或分配值的类似方法返回的值对可以收集大量 PRNG 输出的攻击者来说是可预测的。

示例 1：可以通过 Random 对象 randomGen1 来预测 Random 对象 randomGen2 生成的值。

        val randomGen1 = Random(12345)
        val randomInt1 = randomGen1.nextInt()
        val byteArray1 = ByteArray(4)
        randomGen1.nextBytes(byteArray1)

        val randomGen2 = Random(12345)
        val randomInt2 = randomGen2.nextInt()
        val byteArray2 = ByteArray(4)
        randomGen2.nextBytes(byteArray2)

在此示例中，伪随机数值生成器：randomGen1 和 randomGen2 设置了相同的种子，因此 randomInt1 == randomInt2，且数组 byteArray1 和 byteArray2 的相应值是相等的。

可生成伪随机值的传递种子的函数不应使用常量整数参数进行调用。如果伪随机数生成器使用特定值作为种子，则返回的值可预测。

示例 1：伪随机数生成器生成的值在前两个块中是可预测的，因为这两个块以同一种子开始。

...
import random
random.seed(123456)
print "Random: %d" % random.randint(1,100)
print "Random: %d" % random.randint(1,100)
print "Random: %d" % random.randint(1,100)

random.seed(123456)
print "Random: %d" % random.randint(1,100)
print "Random: %d" % random.randint(1,100)
print "Random: %d" % random.randint(1,100)
...

在此示例中，PRNG 设置了相同的种子，因此，在为伪随机数生成器 (random.seed(123456)) 设置种子的调用后，对 randint() 的每次调用都将会导致按相同的顺序显示相同的输出。例如，输出可能与以下内容相似：

Random: 81
Random: 80
Random: 3
Random: 81
Random: 80
Random: 3

这些结果并不是随机的。

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。如果伪随机数值生成器（如 Random）使用特定值作为种子（使用诸如 Random.setSeed() 的函数），则通过 Random.nextInt() 和通过可返回或分配值的类似方法返回的值对可以收集大量 PRNG 输出的攻击者来说是可预测的。

示例 1：可以通过 Random 对象 randomGen1 来预测 Random 对象 randomGen2 生成的值。

        val randomGen1 = new Random()
        randomGen1.setSeed(12345)
        val randomInt1 = randomGen1.nextInt()
        val bytes1 = new byte[4]
        randomGen1.nextBytes(bytes1)

        val randomGen2 = new Random()
        randomGen2.setSeed(12345)
        val randomInt2 = randomGen2.nextInt()
        val bytes2 = new byte[4]
        randomGen2.nextBytes(bytes2)

在此示例中，伪随机数值生成器：randomGen1 和 randomGen2 设置了相同的种子，因此 randomInt1 == randomInt2，且数组 bytes1[] 和 bytes2[] 的相应值是相等的。

类 CL_ABAP_RANDOM（或其变体）不应使用受污染参数进行初始化。这样做可使攻击者控制作为伪随机数值生成器种子的值，因此能够预测由调用方法产生的值的顺序，这些方法包括但不限于： GET_NEXT, INT, FLOAT, PACKED.

对于生成了传递了种子（如 rand()）的随机或伪随机值（如 srand()）的函数，不应该使用受污染的参数进行调用。这样做可使攻击者控制作为伪随机数值生成器种子的值，因此能够预测由调用随机数值生成器产生的值（通常为整数）的顺序。

可生成伪随机数值的函数（如 ed25519.NewKeyFromSeed()）不应使用受污染参数进行调用。这样做可使攻击者控制作为伪随机数值生成器种子的值，然后可以预测由调用伪随机数值生成器产生的值的顺序。

Random.setSeed() 不应使用受污染的整数参数进行调用。这样做可使攻击者控制作为伪随机数值生成器种子的值，因此能够预测由调用 Random.nextInt()、Random.nextLong()、Random.nextDouble() 产生的、或 Random.nextBoolean() 返回的、或在 Random.nextBytes(ByteArray) 中设置的值（通常为整数）的顺序。

可生成伪随机值的函数（如 random.randint()）；不应使用受污染参数进行调用。否则攻击者可以控制用作伪随机数生成器种子的值，从而能够预测由伪随机数生成器调用产生的值（通常为整数）的顺序。

Random.setSeed() 不应使用受污染的整数参数进行调用。这样做可使攻击者控制作为伪随机数值生成器种子的值，因此能够预测由调用 Random.nextInt()、Random.nextShort()、Random.nextLong() 产生的、或 Random.nextBoolean() 返回的、或在 Random.nextBytes(byte[]) 中设置的值（通常为整数）的顺序。

公钥基础架构 (PKI) 基于受信任的证书颁发机构 (CA)，但盗用的证书颁发机构的数量不断增加，这意味着其根证书无法再受到信任，因此由该 CA 签名的证书也不再受到信任。拥有这些盗用证书的攻击者将能够拦截所有信任这些 CA 的 SSL/TLS 信息流。

证书颁发机构的签名对于浏览器等通用网络通信工具而言是必不可少的，这些工具连接到任意网络端点，并且事先并不知道哪些 CA 对这些端点的 SSL/TLS 证书进行了签名。对于连接到有限的后端服务器的移动应用程序，如果它们知道这些服务器在对其证书进行签名时可能会使用的若干受信任 CA，则这些应用程序可从中获益，并在应用程序中“固定”这些证书/公钥，以便仅信任应用程序需要的证书。

示例 1：下面的示例会使用默认的预加载系统 CA 建立 SSL/TLS 连接。

val url = URL("https://myserver.org")
val data = url.readBytes()

由于 URLConnection 所使用的基础 SSLSocketFactory 未更改，它将使用信任 Android 默认密钥库中存在的所有 CA 的默认项。

公钥基础架构 (PKI) 基于受信任的证书颁发机构 (CA)，但盗用的证书颁发机构的数量不断增加，这意味着其根证书无法再受到信任，因此由该 CA 签名的证书也不再受到信任。拥有这些盗用证书的攻击者将能够拦截所有信任这些 CA 的 SSL/TLS 信息流。

证书颁发机构的签名对于浏览器等通用网络通信工具而言是必不可少的，这些工具连接到任意网络端点，并且事先并不知道哪些 CA 对这些端点的 SSL/TLS 证书进行了签名。对于连接到有限的后端服务器的移动应用程序，如果它们知道这些服务器在对其证书进行签名时可能会使用的若干受信任 CA，则这些应用程序可从中获益，并在应用程序中“固定”这些证书/公钥，以便仅信任应用程序需要的证书。

示例 1：下面的示例会使用默认的预加载系统 CA 建立 SSL/TLS 连接。

NSString* requestString = @"https://myserver.org";
NSURL* requestUrl = [NSURL URLWithString:requestString];
NSURLRequest* request = [NSURLRequest requestWithURL:requestUrl
                                         cachePolicy:NSURLRequestReloadIgnoringLocalCacheData
                                     timeoutInterval:10.0f];
NSURLConnection* connection = [[NSURLConnection alloc] initWithRequest:request delegate:self];

由于未定义任何 NSURLConnectionDelegate 方法来处理证书验证，它将使用信任 iOS 默认密钥库中存在的所有 CA 的系统方法。

公钥基础架构 (PKI) 基于受信任的证书颁发机构 (CA)，但盗用的证书颁发机构的数量不断增加，这意味着其根证书无法再受到信任，因此由该 CA 签名的证书也不再受到信任。拥有这些盗用证书的攻击者将能够拦截所有信任这些 CA 的 SSL/TLS 信息流。

证书颁发机构的签名对于浏览器等通用网络通信工具而言是必不可少的，这些工具连接到任意网络端点，并且事先并不知道哪些 CA 对这些端点的 SSL/TLS 证书进行了签名。对于连接到有限的后端服务器的移动应用程序，如果它们知道这些服务器在对其证书进行签名时可能会使用的若干受信任 CA，则这些应用程序可从中获益，并在应用程序中“固定”这些证书/公钥，以便仅信任应用程序需要的证书。

示例 1：下面的示例会使用默认的预加载系统 CA 建立 SSL/TLS 连接。

let requestString = NSURL(string: "https://myserver.org") 
let requestUrl : NSURL = NSURL(string:requestString)!;
let request : NSURLRequest = NSURLRequest(URL:requestUrl);
let connection : NSURLConnection = NSURLConnection(request:request, delegate:self)!;

由于未定义任何 NSURLConnectionDelegate 方法来处理证书验证，它将使用信任 iOS 默认密钥库中存在的所有 CA 的系统方法。

在某些使用 SSL 连接的库中，默认情况下不验证服务器证书。这相当于信任所有证书。在其他实例中，这可以被显式禁用，而不管有意还是无意。

示例 1：此应用程序始终验证证书链是否正确，进而信任所有证书。

...
private bool CertificateCheck(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
  ...
  return true; 
}
...
  HttpWebRequest webRequest = (HttpWebRequest) WebRequest.Create("https://www.myTrustedSite.com");
  webRequest.ServerCertificateValidationCallback = CertificateCheck;
  WebResponse response = webRequest.GetResponse();
...

当尝试连接到“https://www.myTrustedSite.com”时，此应用程序将随时接受颁发给“hackedserver.com”的证书。此时，当服务器被黑客攻击发生 SSL 连接中断时，应用程序可能会泄漏用户敏感信息。

在一些使用 SSL 连接的库中，可以禁用服务器证书验证。这相当于信任所有证书。

例 1： 此应用程序显式禁用了证书验证：

...
  SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, verify_callback);
...

当尝试连接到有效主机时，此应用程序将随时接受颁发给“hackedserver.com”的证书。此时，当服务器被黑客攻击发生 SSL 连接中断时，应用程序可能会泄漏用户敏感信息。

在某些使用 SSL 连接的库中，默认情况下不验证服务器证书。这相当于信任所有证书。

示例 1：此应用程序没有明确地验证服务器证书。

    ...
    config := &tls.Config{
        // Set InsecureSkipVerify to skip the default validation
        InsecureSkipVerify: true,
        ...
    }

    conn, err := tls.Dial("tcp", "example.com:443", conf)
    ..
    

尝试连接到 example.com 时，此应用程序会随时接受服务器颁发的任何证书。当服务器被黑客攻击发生 SSL 连接中断时，此应用程序可能会泄漏用户敏感信息。

在某些使用 SSL 连接的库中，默认情况下不验证服务器证书。这相当于信任所有证书。

示例 1：此服务器错误地尝试验证客户端连接：

...
var options = {
  key : fs.readFileSync('my-server-key.pem'),
  cert : fs.readFileSync('server-cert.pem'),
  requestCert: true,
  ...
}
https.createServer(options);
...

创建 https.Server 对象时，requestCert 设置会指定为 true，但未设置 rejectUnauthorized，其默认设置为 false。这意味着尽管服务器是为了通过 SSL 验证客户端而创建，但即使未使用提供的 CA 列表对证书进行授权，也仍然会接受连接。

示例 2：此应用程序尝试通过 SSL 连接到服务器：

var tls = require('tls');
...
tls.connect({
  host: 'https://www.hackersite.com',
  port: '443',
  ...
  rejectUnauthorized: false,
  ...
});

在此示例中，如果 rejectUnauthorized 设置为 false，这意味着将接受未经授权的证书，并且仍然会与无法识别的服务器建立安全连接。此时，当服务器被黑客攻击发生 SSL 连接中断时，应用程序可能会泄漏用户敏感信息。

在某些使用 SSL 连接的库中，默认情况下不验证服务器证书（或可以通过显式配置这样做）。这相当于信任所有证书。

示例 1：此代码将 NSURLConnectionDelegate 配置为接受任意 HTTPS 证书：

implementation NSURLRequest (IgnoreSSL)

+ (BOOL)allowsAnyHTTPSCertificateForHost:(NSString *)host
{
  return YES;
}

@end

当尝试使用Example 1 中的 NSURLRequest 实现方式连接到受 SSL 保护的服务器时，如果所请求服务器的证书为自签名证书（进而未经验证），则不会出现警告或错误。因此，应用程序现在可能会通过断开的 SSL 连接泄漏敏感的用户信息。

在一些使用 SSL 连接的库中，可以禁用服务器证书验证。这相当于信任所有证书。

例 1：此应用程序在默认情况下不会验证服务器证书：

...
import ssl
ssl_sock = ssl.wrap_socket(s)
...

当尝试连接到有效主机时，此应用程序将随时接受颁发给“hackedserver.com”的证书。此时，当服务器被黑客攻击发生 SSL 连接中断时，应用程序可能会泄漏用户敏感信息。

在一些使用 SSL 连接的库中，可以禁用服务器证书验证。这相当于信任所有证书。

例 1： 此应用程序显式禁用了证书验证：

require 'openssl'
...
ctx = OpenSSL::SSL::SSLContext.new
ctx.verify_mode=OpenSSL::SSL::VERIFY_NONE
...

当尝试连接到有效主机时，此应用程序将随时接受颁发给“hackedserver.com”的证书。此时，当服务器被黑客攻击发生 SSL 连接中断时，应用程序可能会泄漏用户敏感信息。

在某些使用 SSL 连接的库中，默认情况下不验证服务器证书（或可以通过显式配置这样做）。这相当于信任所有证书。

示例 1：此代码将 NSURLConnectionDelegate 配置为接受任意 HTTPS 证书：

class Delegate: NSObject, NSURLConnectionDelegate {
    
    ...

    func connection(connection: NSURLConnection, canAuthenticateAgainstProtectionSpace protectionSpace: NSURLProtectionSpace?) -> Bool {
        return protectionSpace?.authenticationMethod == NSURLAuthenticationMethodServerTrust
    }

    func connection(connection: NSURLConnection, willSendRequestForAuthenticationChallenge challenge: NSURLAuthenticationChallenge) {
        challenge.sender?.useCredential(NSURLCredential(forTrust: challenge.protectionSpace.serverTrust!), forAuthenticationChallenge: challenge)
        challenge.sender?.continueWithoutCredentialForAuthenticationChallenge(challenge)
    }
}

当尝试使用Example 1 中的 NSURLConnectionDelegate 实现方式连接到受 SSL 保护的服务器时，如果所请求服务器的证书为自签名证书（进而未经验证），则不会出现警告或错误。因此，应用程序现在可能会通过断开的 SSL 连接泄漏敏感的用户信息。

示例 2：在 NSURLSession 类中，SSL/TLS 链验证由您的应用程序的身份验证代理方法进行处理，但是您的应用程序并未向服务器提供用于验证用户或应用程序的凭据，而是检查服务器在 SSL/TLS 握手期间提供的凭据，然后告诉 URL 加载系统是应接受还是应拒绝这些凭据。以下代码显示的 NSURLSessionDelgate 直接将接收到的质询中的 proposedCredential 作为会话凭据传回，从而成功绕过了服务器验证：

class MySessionDelegate : NSObject, NSURLSessionDelegate {
    ...
    func URLSession(session: NSURLSession, didReceiveChallenge challenge: NSURLAuthenticationChallenge, completionHandler: (NSURLSessionAuthChallengeDisposition, NSURLCredential?) -> Void) {
        ...
        completionHandler(NSURLSessionAuthChallengeDisposition.UseCredential, challenge.proposedCredential)
        ...
    }
    ...
}

HTTP(S) 响应中可能包含敏感数据，例如会话 cookie 和 API 标记。出于性能方面的考虑，URL 加载系统会对所有 HTTP(S) 请求进行缓存，并将它们以未加密的形式保存在 {app ID}/Library/Caches/com.mycompany.myapp/Cache.db* 文件中。

HTTP(S) 响应中可能包含敏感数据，例如会话 cookie 和 API 标记。出于性能方面的考虑，URL 加载系统会对所有 HTTP(S) 请求进行缓存，并将它们以未加密的形式保存在 {app ID}/Library/Caches/com.mycompany.myapp/Cache.db* 文件中。