在安全性要求較高的環境中，將一個能夠產生可預測值的函數當作隨機來源使用時，會產生 Insecure Randomness 錯誤。

電腦是一種決定性的機器，因此不可能產生真正的隨機性。虛擬亂數產生器 (PRNG, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容，但是它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來解決這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 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, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容，但是它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來解決這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 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, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容，但是它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來解決這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 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, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容，但是它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來解決這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 1：以下程式碼使用統計式 PRNG，為購買後仍在有效期內的收據建立 URL。

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

此程式碼使用 Rand() 函數為其所產生的收據頁面產生「唯一」識別碼。由於 Rand() 是統計式 PRNG，攻擊者很容易就能猜到其所產生的字串。雖然收據系統的基礎設計也存在錯誤，但是如果它使用一個不會產生可預測收據識別碼的亂數產生器 (例如加密式 PRNG)，那就會安全很多。

在安全性要求較高的環境中，將一個能夠產生可預測值的函數當作隨機來源使用時，會產生 Insecure Randomness 錯誤。

電腦是一種決定性的機器，因此不可能產生真正的隨機性。虛擬亂數產生器 (PRNG, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容。但是，它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來處理這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 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, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容，但是它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來解決這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 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, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容，但是它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來解決這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 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, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容，但是它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來解決這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 1：以下程式碼使用統計式 PRNG，為購買後仍在有效期內的收據建立 URL。

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

此程式碼使用 rand() 函數為其所產生的收據頁面產生「唯一」識別碼。由於 rand() 是統計式 PRNG，攻擊者很容易就能猜到其所產生的字串。雖然收據系統的基礎設計也存在錯誤，但是如果它使用一個不會產生可預測收據識別碼的亂數產生器 (例如加密式 PRNG)，那就會安全很多。

在安全性較高的環境中，將一個能夠產生可預測值的函數當作亂數來源使用時，會產生 Insecure Randomness 錯誤。

電腦是一種決定性的機器，因此不可能產生真正的隨機性。虛擬亂數產生器 (PRNG, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容，但是它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來解決這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 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, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容，但是它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來解決這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 1：以下程式碼使用統計式 PRNG，為購買後仍在有效期內的收據建立 URL。

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

此程式碼使用 rand() 函數為其所產生的收據頁面產生「唯一」識別碼。由於 rand() 是統計式 PRNG，攻擊者很容易就能猜到其所產生的字串。雖然收據系統的基礎設計也存在錯誤，但是如果它使用一個不會產生可預測收據識別碼的亂數產生器 (例如加密式 PRNG)，那就會安全很多。

在安全性要求較高的環境中，將一個能夠產生可預測值的函數當作隨機來源使用時，會產生 Insecure Randomness 錯誤。

電腦是一種決定性的機器，因此不可能產生真正的隨機性。虛擬亂數產生器 (PRNG, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容，但是它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來解決這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 1：以下程式碼使用統計式 PRNG，為購買後仍在有效期內的收據建立 URL。

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

此程式碼使用 Kernel.rand() 函數為其所產生的收據頁面產生「唯一」識別碼。由於 Kernel.rand() 是統計式 PRNG，攻擊者很容易就能猜到其所產生的字串。

在安全性要求較高的環境中，將一個能夠產生可預測值的函數當作隨機來源使用時，會產生 Insecure Randomness 錯誤。

電腦是一種決定性的機器，因此不可能產生真正的隨機性。虛擬亂數產生器 (PRNG, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容，但是它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來解決這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 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, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容，但是它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來解決這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 1：以下程式碼使用統計 PRNG 來建立隨機值，此值將用作重設密碼權杖。

    sqlite3_randomness(10, &reset_token)

在安全性要求較高的環境中，將一個能夠產生可預測值的函數當作隨機來源使用時，會產生 Insecure Randomness 錯誤。

電腦是一種決定性的機器，因此不可能產生真正的隨機性。虛擬亂數產生器 (PRNG, Pseudorandom Number Generator) 近似於隨機演算，會從一個可以計算後續值的種子開始。

PRNG 包括兩種類型：統計式和加密式。統計式 PRNG 可提供有用的統計內容，但是它們的輸出很容易預測，導致複製數值串流很容易。因此，對於因安全性由產生數值決定而導致其不可預測的環境，其並不適用。加密式 PRNG 則會藉由產生更難以預測的輸出來解決這個問題。若要對數值進行加密保護，必須使攻擊者無法或難以區別產生的隨機數值和真實的隨機數值。一般來說，如果沒有指出某個 PRNG 演算法經過加密保護，那麼它很可能是統計式 PRNG，不應在安全性要求較高的環境中使用，否則會引發嚴重弱點，例如易猜的臨時密碼、容易預測的加密金鑰、Session Hijacking 以及 DNS 欺騙。

範例 1：以下程式碼使用統計式 PRNG，為購買後仍在有效期內的收據建立 URL。

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

此程式碼使用 Rnd() 函數為其所產生的收據頁面產生「唯一」識別碼。由於 Rnd() 是統計式 PRNG，攻擊者很容易就能猜到其所產生的字串。雖然收據系統的基礎設計也存在錯誤，但是如果它使用一個不會產生可預測收據識別碼的亂數產生器 (例如加密式 PRNG)，那就會安全很多。

這些函數可產生隨機值或虛擬隨機值 (已向這些值傳送種子)，不應使用常數引數呼叫這些函數。如果使用特定常數值向虛擬亂數產生器 (例如 CL_ABAP_RANDOM 類別或其變體) 提供種子，則可收集大量 PRNG 輸出的攻擊者將可預測由 GET_NEXT、INT 和用於傳回或指派值的類似方法傳回的值。

範例 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

這些函數可產生隨機值或虛擬隨機值 (已向這些值傳送種子)，不應使用常數引數呼叫這些函數。如果使用特定值 (使用類似 srand(unsigned int) 的函數) 向虛擬亂數產生器 (例如 rand()) 提供種子，則可收集大量 PRNG 輸出的攻擊者將可預測由 rand() 和用於傳回或指派值的類似方法傳回的值。

範例 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) 等函數) 作為種子，則可收集大量 PRNG 輸出的攻擊者將可預測由 math.Rand.Int() 和用於回傳或指派值的類似方法回傳的值。

範例 1：由虛擬亂數產生器產生的值在前兩個區塊中是可預測的，因為這兩個區塊以相同的種子開始。

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

在此範例中，以完全相同的方式向 PRNG 提供種子，因此，在向虛擬亂數產生器 (randomGen.Seed(12345)) 提供種子的呼叫後，每次對 nextInt() 的呼叫都按照相同的順序產生相同的輸出。

這些函數可產生隨機值或虛擬隨機值 (已向這些值傳送種子)，不應使用常數引數呼叫這些函數。如果使用特定值 (使用 Random(Int) 等的函數) 向虛擬亂數產生器 (例如 Random) 提供種子，則可收集大量 PRNG 輸出的攻擊者將可預測由 Random.nextInt() 和用於回傳或指派值的類似方法回傳的值。

範例 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.setSeed() 的函數) 向虛擬亂數產生器 (例如 Random) 提供種子，則可收集大量 PRNG 輸出的攻擊者將可預測由 Random.nextInt() 和用於傳回或指派值的類似方法傳回的值。

範例 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，這些伺服器會使用這些 CA 來簽署其憑證並在應用程式中「釘選」這些憑證/公開金鑰，以便將信任降低至應用程式預期的憑證。

範例 1：以下範例使用預先載入的預設系統 CA 建立 SSL/TLS 連線。

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

由於 URLConnection 使用的基礎 SSLSocketFactory 尚未變更，因此，它將使用將信任 Android 預設 Keystore 中存在的所有 CA 的預設值。

公開金鑰基礎結構 (PKI) 是以信任的憑證授權單位 (CA) 為基礎，但是越來越多受損憑證授權單位意味著它們的根憑證不再受到信任，因此，由此 CA 簽署的憑證也不再受到信任。擁有這些受損憑證的攻擊者將能夠攔截所有信任這些 CA 的 SSL/TLS 流量。

憑證授權單位簽章對於一般用途的網路通訊工具是必要的，例如，連線至任意網路端點以及沒有事先暸解哪些 CA 針對這些端點簽署 SSL/TLS 憑證的瀏覽器。連線至有限後端伺服器的行動應用程式可受益於暸解少數幾個信任的 CA，這些伺服器會使用這些 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 預設 Keystore 中存在的所有 CA 的系統方法。

公開金鑰基礎結構 (PKI) 是以信任的憑證授權單位 (CA) 為基礎，但是越來越多受損憑證授權單位意味著它們的根憑證不再受到信任，因此，由此 CA 簽署的憑證也不再受到信任。擁有這些受損憑證的攻擊者將能夠攔截所有信任這些 CA 的 SSL/TLS 流量。

憑證授權單位簽章對於一般用途的網路通訊工具是必要的，例如，連線至任意網路端點以及沒有事先暸解哪些 CA 針對這些端點簽署 SSL/TLS 憑證的瀏覽器。連線至有限後端伺服器的行動應用程式可受益於暸解少數幾個信任的 CA，這些伺服器會使用這些 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 預設 Keystore 中存在的所有 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 載入系統應接受還是拒絕這些憑證。以下程式碼顯示 proposedCredential 剛剛將所收到的挑戰之 NSURLSessionDelgate 傳回作為階段作業的憑證，以有效地避開伺服器驗證：

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* 檔案中。