Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.

Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis, mas sua saída é altamente previsível e forma um fluxo numérico fácil de reproduzir que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O código a seguir usa um PRNG estatístico para criar uma URL para um recibo que permanece ativo por um determinado período após uma compra.

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.

Esse código usa a função CL_ABAP_RANDOM->INT31 para gerar identificadores "exclusivos" para as páginas de recibo que ele gera. Como CL_ABAP_RANDOM é um PRNG estatístico, é fácil para um invasor adivinhar as strings que ele gera. Embora o design subjacente do sistema de recibos também tenha suas falhas, ele seria mais seguro se utilizasse um gerador de números aleatórios que não produzisse identificadores de recibo previsíveis, como um PRNG criptográfico.

Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.

Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis, mas sua saída é altamente previsível e forma um fluxo numérico fácil de reproduzir que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O código a seguir usa um PRNG estatístico para criar uma URL para um recibo que permanece ativo por um determinado período após uma compra.

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

Esse código usa a função Random.Next() para gerar identificadores "exclusivos" para as páginas de recibo que ele gera. Como Random.Next() é um PRNG estatístico, é fácil para um invasor adivinhar as strings que ele gera. Embora o design subjacente do sistema de recibos também tenha suas falhas, ele seria mais seguro se utilizasse um gerador de números aleatórios que não produzisse identificadores de recibo previsíveis, como um PRNG criptográfico.

Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.

Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis, mas sua saída é altamente previsível e forma um fluxo numérico fácil de reproduzir que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O código a seguir usa um PRNG estatístico para criar uma URL para um recibo que permanece ativo por um determinado período após uma compra.

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;
}

Esse código usa a função lrand48() para gerar identificadores "exclusivos" para as páginas de recibo que ele gera. Como lrand48() é um PRNG estatístico, é fácil para um invasor adivinhar as strings que ele gera. Embora o design subjacente do sistema de recibos também tenha suas falhas, ele seria mais seguro se utilizasse um gerador de números aleatórios que não produzisse identificadores de recibo previsíveis.

Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.


Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis, mas sua saída é altamente previsível e forma um fluxo numérico fácil de reproduzir que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O código a seguir usa um PRNG estatístico para criar uma URL para um recibo que permanece ativo por um determinado período após uma compra.

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

Esse código usa a função Rand() para gerar identificadores "exclusivos" para as páginas de recibo que ele gera. Como Rand() é um PRNG estatístico, é fácil para um invasor adivinhar as strings que ele gera. Embora o design subjacente do sistema de recibos também tenha suas falhas, ele seria mais seguro se utilizasse um gerador de números aleatórios que não produzisse identificadores de recibo previsíveis, como um PRNG criptográfico.

Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.

Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis. No entanto, têm uma saída altamente previsível e formam um fluxo numérico fácil de reproduzir, o que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O seguinte código usa um PRNG estatístico para criar uma chave RSA.

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

Esse código usa a função rand.New() para gerar aleatoriedade para uma chave RSA. Como rand.New() é um PRNG estatístico, é fácil para um invasor adivinhar o valor que ele gera.

Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.

Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis, mas sua saída é altamente previsível e forma um fluxo numérico fácil de reproduzir que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O código a seguir usa um PRNG estatístico para criar uma URL para um recibo que permanece ativo por um determinado período após uma compra.

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

Esse código usa a função Math.random() para gerar identificadores "exclusivos" para as páginas de recibo que ele gera. Como Math.random() é um PRNG estatístico, é fácil para um invasor adivinhar as strings que ele gera. Embora o design subjacente do sistema de recibos também tenha suas falhas, ele seria mais seguro se utilizasse um gerador de números aleatórios que não produzisse identificadores de recibo previsíveis, como um PRNG criptográfico.

Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.

Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis, mas sua saída é altamente previsível e forma um fluxo numérico fácil de reproduzir que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O código a seguir usa um PRNG estatístico para criar uma URL para um recibo que permanece ativo por um determinado período após uma compra.

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

Esse código usa a função Random.nextInt() para gerar identificadores "exclusivos" para as páginas de recibo que ele gera. Como Random.nextInt() é um PRNG estatístico, é fácil para um invasor adivinhar as cadeias de caracteres que ele gera. Embora o design subjacente do sistema de recibos também tenha suas falhas, ele seria mais seguro se utilizasse um gerador de números aleatórios que não produzisse identificadores de recibo previsíveis, como um PRNG criptográfico.

Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.

Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis, mas sua saída é altamente previsível e forma um fluxo numérico fácil de reproduzir que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O código a seguir usa um PRNG estatístico para criar uma URL para um recibo que permanece ativo por um determinado período após uma compra.

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

Esse código usa a função rand() para gerar identificadores "exclusivos" para as páginas de recibo que ele gera. Como rand() é um PRNG estatístico, é fácil para um invasor adivinhar as strings que ele gera. Embora o design subjacente do sistema de recibos também tenha suas falhas, ele seria mais seguro se utilizasse um gerador de números aleatórios que não produzisse identificadores de recibo previsíveis, como um PRNG criptográfico.

Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.

Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis, mas sua saída é altamente previsível e forma um fluxo numérico fácil de reproduzir que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O código a seguir usa um PRNG estatístico para criar uma URL para um recibo que permanece ativo por um determinado período após uma compra.

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

Esse código usa a função DBMS_RANDOM.SEED() para gerar identificadores "exclusivos" para as páginas de recibo que ele gera. Como DBMS_RANDOM.SEED() é um PRNG estatístico, é fácil para um invasor adivinhar as strings que ele gera. Embora o design subjacente do sistema de recibos também tenha suas falhas, ele seria mais seguro se utilizasse um gerador de números aleatórios que não produzisse identificadores de recibo previsíveis.

Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.

Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis, mas sua saída é altamente previsível e forma um fluxo numérico fácil de reproduzir que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O código a seguir usa um PRNG estatístico para criar uma URL para um recibo que permanece ativo por um determinado período após uma compra.

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

Esse código usa a função rand() para gerar identificadores "exclusivos" para as páginas de recibo que ele gera. Como rand() é um PRNG estatístico, é fácil para um invasor adivinhar as strings que ele gera. Embora o design subjacente do sistema de recibos também tenha suas falhas, ele seria mais seguro se utilizasse um gerador de números aleatórios que não produzisse identificadores de recibo previsíveis, como um PRNG criptográfico.

Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.

Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis, mas sua saída é altamente previsível e forma um fluxo numérico fácil de reproduzir que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O código a seguir usa um PRNG estatístico para criar uma URL para um recibo que permanece ativo por um determinado período após uma compra.

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

Esse código usa a função Kernel.rand() para gerar identificadores "exclusivos" para as páginas de recibo que ele gera. Como Kernel.rand() é um PRNG estatístico, é fácil para um invasor adivinhar as strings que ele gera.

Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.

Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis, mas sua saída é altamente previsível e forma um fluxo numérico fácil de reproduzir que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O código a seguir usa um PRNG estatístico para criar uma URL para um recibo que permanece ativo por um determinado período após uma compra.

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

Esse código usa a função Random.nextInt() para gerar identificadores "exclusivos" para as páginas de recibo que ele gera. Como Random.nextInt() é um PRNG estatístico, é fácil para um invasor adivinhar as strings que ele gera. Embora o design subjacente do sistema de recibos também tenha suas falhas, ele seria mais seguro se utilizasse um gerador de números aleatórios que não produzisse identificadores de recibo previsíveis, como um PRNG criptográfico.

Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.

Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis, mas sua saída é altamente previsível e forma um fluxo numérico fácil de reproduzir que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O código a seguir usa um PRNG estatístico para criar um valor aleatório que é usado como um token de senha redefinido.

    sqlite3_randomness(10, &reset_token)

Erros de aleatoriedade insegura ocorrem quando uma função que pode produzir valores previsíveis é usada como fonte de aleatoriedade em um contexto sensível à segurança.

Computadores são máquinas determinísticas e, como tais, são incapazes de produzir uma aleatoriedade verdadeira. PRNGs (Geradores de Números Pseudoaleatórios) aproximam a aleatoriedade algoritmicamente, começando com um propagador a partir do qual valores subsequentes são calculados.

Existem dois tipos de PRNGs: estatísticos e criptográficos. PRNGs estatísticos fornecem propriedades estatísticas úteis, mas sua saída é altamente previsível e forma um fluxo numérico fácil de reproduzir que é inadequado para uso em casos nos quais a segurança depende da imprevisibilidade dos valores gerados. PRNGs criptográficos resolvem esse problema, gerando uma saída que é mais difícil de prever. Para que um valor seja criptograficamente seguro, deve ser impossível ou altamente improvável que um invasor consiga distinguir entre o valor aleatório gerado e um valor realmente aleatório. Em geral, quando um algoritmo PRNG não é anunciado como criptograficamente seguro, é provável que ele seja um PRNG estatístico e, portanto, não deve ser usado em contextos sensíveis à segurança, nos quais sua utilização pode resultar em sérias vulnerabilidades, como senhas temporárias fáceis de adivinhar, chaves criptográficas previsíveis, sequestro de sessão e falsificação de DNS.

Exemplo 1: O código a seguir usa um PRNG estatístico para criar uma URL para um recibo que permanece ativo por um determinado período após uma compra.

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

Esse código usa a função Rnd() para gerar identificadores "exclusivos" para as páginas de recibo que ele gera. Como Rnd() é um PRNG estatístico, é fácil para um invasor adivinhar as strings que ele gera. Embora o design subjacente do sistema de recibos também tenha suas falhas, ele seria mais seguro se utilizasse um gerador de números aleatórios que não produzisse identificadores de recibo previsíveis, como um PRNG criptográfico.

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante. Se um gerador de números pseudoaleatórios (como a classe CL_ABAP_RANDOM ou suas variantes) for propagado com um valor constante específico, os valores retornados por GET_NEXT, INT e métodos semelhantes que retornam ou atribuem valores serão previsíveis para um invasor, que poderá coletar várias saídas PRNG.

Exemplo 1: No trecho a seguir, os valores produzidos pelo objeto random_gen2 são previsíveis por meio do objeto random_gen1.

		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.

Neste exemplo, os geradores de números pseudoaleatórios: random_gen1 e random_gen2 foram semeados de forma idêntica, então var1 = var2

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante. Se um gerador de números pseudoaleatórios (como rand()) for propagado com um valor específico (usando uma função como srand(unsigned int)), os valores retornados por rand() e métodos semelhantes que retornam ou atribuem valores serão previsíveis para um invasor, que poderá coletar várias saídas de PRNG.

Exemplo 1: Os valores produzidos pelo gerador de números pseudoaleatórios são previsíveis nos dois primeiros blocos, pois ambos começam com o mesmo propagador.

        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);

Nesse exemplo, os resultados para randomNum1 e randomNum2 foram identicamente propagados e, portanto, cada chamada para rand() após a chamada que propaga o gerador de números pseudoaleatórios srand(2223333) resultará nas mesmas saídas, na mesma ordem de chamada. Por exemplo, a saída pode ser semelhante à seguinte:

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

Esses resultados estão longe de serem aleatórios.

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante. Se um gerador de números pseudoaleatórios (PRNG) for propagado com um valor específico (usando uma função como math.Rand.New(Source)), os valores retornados por math.Rand.Int() e métodos semelhantes que retornam ou atribuem valores serão previsíveis para um invasor, que poderá coletar várias saídas do PRNG.

Exemplo 1: Os valores produzidos pelo gerador de números pseudoaleatórios são previsíveis nos dois primeiros blocos, pois ambos começam com o mesmo propagador.

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

Neste exemplo, os PRNGs foram propagados com o mesmo valor. Assim, cada chamada denextInt() após a chamada que iniciou a propagação do gerador de números pseudoaleatórios (randomGen.Seed(12345)) resultará nas mesmas saídas, na mesma ordem.

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante. Se um gerador de números pseudoaleatórios (como Random) for propagado com um valor específico (usando uma função como Random(Int)), os valores retornados por Random.nextInt() e métodos semelhantes que retornam ou atribuem valores serão previsíveis para um invasor, que poderá coletar várias saídas de PRNG.

Exemplo 1: Os valores produzidos pelo objeto RandomrandomGen2 são previsíveis com base no objeto RandomrandomGen1.

        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)

Neste exemplo, os geradores de números pseudoaleatórios: randomGen1 e randomGen2 foram propagados de forma idêntica e, portanto, randomInt1 == randomInt2 e os valores correspondentes dos arrays byteArray1 e byteArray2 são iguais.

As funções que geram valores pseudoaleatórios, que são passados a uma semente, não devem ser chamadas com um argumento inteiro constante. Se um gerador de números pseudoaleatórios for semeado com um valor específico, os valores devolvidos serão previsíveis.

Exemplo 1: Os valores produzidos pelo gerador de números pseudoaleatórios são previsíveis nos dois primeiros blocos, pois ambos começam com o mesmo propagador.

...
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)
...

Nesse exemplo, os PRNGs foram semeados de maneira idêntica, para que cada chamada de randint() feita depois da chamada que semeou o gerador de números pseudoaleatórios (random.seed(123456)), resulte nas mesmas saídas na mesma ordem. Por exemplo, a saída pode ser semelhante à seguinte:

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

Esses resultados estão longe de serem aleatórios.

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante. Se um gerador de números pseudoaleatórios (como Random) for propagado com um valor específico (usando uma função como Random.setSeed()), os valores retornados por Random.nextInt() e métodos semelhantes que retornam ou atribuem valores serão previsíveis para um invasor, que poderá coletar várias saídas de PRNG.

Exemplo 1: Os valores produzidos pelo objeto RandomrandomGen2 são previsíveis com base no objeto RandomrandomGen1.

        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)

Neste exemplo, os geradores de números pseudoaleatórios: randomGen1 e randomGen2 foram propagados de forma idêntica e, portanto, randomInt1 == randomInt2 e os valores correspondentes dos arrays bytes1[] e bytes2[] são iguais.

A classe CL_ABAP_RANDOM (ou suas variantes) não deve ser inicializada com um argumento corrompido. Se isso for feito, um invasor poderá controlar o valor usado para propagar o gerador de números pseudoaleatórios e, portanto, prever a sequência de valores produzidos por chamadas para métodos, incluindo, sem limitações: GET_NEXT, INT, FLOAT, PACKED.

Funções que geram valores aleatórios ou pseudoaleatórios (como rand()), que são transmitidos para um propagador (como srand()), não devem ser chamadas com um argumento corrompido. Se isso for feito, um invasor poderá controlar o valor usado para propagar o gerador de números pseudoaleatórios e, portanto, prever a sequência de valores (geralmente números inteiros) produzidos por chamadas para esse gerador.

Funções que geram valores pseudoaleatórios, como ed25519.NewKeyFromSeed(), não devem ser chamadas com um argumento impróprio. Caso contrário, um invasor poderá controlar o valor usado para propagar o gerador de números pseudoaleatórios e prever a sequência de valores produzidos por esse gerador.

Random.setSeed() não devem ser chamadas com um argumento de número inteiro corrompido. Se isso for feito, um invasor poderá controlar o valor usado para propagar o gerador de números pseudoaleatórios e, portanto, prever a sequência de valores (geralmente números inteiros) produzidos por chamadas para Random.nextInt(), Random.nextLong(), Random.nextDouble(), retornadas por Random.nextBoolean() ou definidas em Random.nextBytes(ByteArray).

Funções que geram valores de pseudoaleatórios (tais como random.randint()); não deve ser chamado com um argumento contaminado. Isso permite a um invasor controlar o valor usado para semear o gerador de números pseudoaleatórios, e, portanto, ser capaz de prever a sequência de valores (geralmente inteiros) produzida pelas chamadas do gerador de números pseudoaleatórios.

Random.setSeed() não devem ser chamadas com um argumento de número inteiro corrompido. Se isso for feito, um invasor poderá controlar o valor usado para propagar o gerador de números pseudoaleatórios e, portanto, prever a sequência de valores (geralmente números inteiros) produzidos por chamadas para Random.nextInt(), Random.nextShort(), Random.nextLong(), retornadas por Random.nextBoolean() ou definidas em Random.nextBytes(byte[]).

A infraestrutura de chave pública (PKI) é baseada em Autoridades de Certificação (ACs) confiáveis. No entanto, o número crescente de Autoridades de Certificação comprometidas significa que os respectivos certificados raiz podem não ser mais confiáveis e, portanto, nenhum certificado assinado por essa AC o será. Os invasores em posse desses certificados comprometidos conseguirão interceptar todo o tráfego SSL/TLS que confia nessas ACs.

As assinaturas de Autoridades de Certificação são necessárias para ferramentas de comunicação de rede de propósito geral, como navegadores que se conectam a pontos de extremidade de rede arbitrários e que não têm conhecimento prévio de quais ACs assinam os certificados SSL/TLS desses pontos de extremidade. Os aplicativos móveis que se conectam a um número limitado de servidores back-end podem se beneficiar com o conhecimento de uma lista pré-selecionada de ACs confiáveis que esses servidores podem usar na assinatura dos respectivos certificados e "fixar" esses certificados/chaves públicas nos aplicativos para que a confiança seja reduzida aos certificados esperados pelo aplicativo.

Exemplo 1: O exemplo a seguir estabelece uma conexão SSL/TLS usando as ACs pré-carregadas padrão do sistema.

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

Como o SSLSocketFactory subjacente usado pelo URLConnection não foi alterado, ele usará o padrão que confiará em todas as ACs presentes no armazenamento de chaves padrão do Android.

A infraestrutura de chave pública (PKI) é baseada em Autoridades de Certificação (ACs) confiáveis. No entanto, o número crescente de Autoridades de Certificação comprometidas significa que os respectivos certificados raiz podem não ser mais confiáveis e, portanto, nenhum certificado assinado por essa AC o será. Os invasores em posse desses certificados comprometidos conseguirão interceptar todo o tráfego SSL/TLS que confia nessas ACs.

As assinaturas de Autoridades de Certificação são necessárias para ferramentas de comunicação de rede de propósito geral, como navegadores que se conectam a pontos de extremidade de rede arbitrários e que não têm conhecimento prévio de quais ACs assinam os certificados SSL/TLS desses pontos de extremidade. Os aplicativos móveis que se conectam a um número limitado de servidores back-end podem se beneficiar com o conhecimento de uma lista pré-selecionada de CAs confiáveis que esses servidores podem usar na assinatura dos respectivos certificados e "fixar" esses certificados/chaves públicas nos aplicativos para que a confiança seja reduzida aos certificados esperados pelo aplicativo.

Exemplo 1: O exemplo a seguir estabelece uma conexão SSL/TLS usando as ACs pré-carregadas padrão do sistema.

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];

Como não há métodos NSURLConnectionDelegate definidos para manipular a verificação de certificados, ele usará os sistemas que confiarão em todas as ACs presente no armazenamento de chaves padrão do iOS.

A infraestrutura de chave pública (PKI) é baseada em Autoridades de Certificação (ACs) confiáveis. No entanto, o número crescente de Autoridades de Certificação comprometidas significa que os respectivos certificados raiz podem não ser mais confiáveis e, portanto, nenhum certificado assinado por essa AC o será. Os invasores em posse desses certificados comprometidos conseguirão interceptar todo o tráfego SSL/TLS que confia nessas ACs.

As assinaturas de Autoridades de Certificação são necessárias para ferramentas de comunicação de rede de propósito geral, como navegadores que se conectam a pontos de extremidade de rede arbitrários e que não têm conhecimento prévio de quais ACs assinam os certificados SSL/TLS desses pontos de extremidade. Os aplicativos móveis que se conectam a um número limitado de servidores back-end podem se beneficiar com o conhecimento de uma lista pré-selecionada de ACs confiáveis que esses servidores podem usar na assinatura dos respectivos certificados e "fixar" esses certificados/chaves públicas nos aplicativos para que a confiança seja reduzida aos certificados esperados pelo aplicativo.

Exemplo 1: O exemplo a seguir estabelece uma conexão SSL/TLS usando as ACs pré-carregadas padrão do sistema.

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)!;

Como não há métodos NSURLConnectionDelegate definidos para manipular a verificação de certificados, ele usará os sistemas que confiarão em todas as ACs presente no armazenamento de chaves padrão do iOS.

Em algumas bibliotecas que usam conexões SSL, o certificado do servidor não é verificado por padrão. Isso é equivalente a confiar em todos os certificados. Em outros casos, isso pode ser explicitamente desativado, seja por intenção ou não.

Exemplo 1: Este aplicativo sempre verifica se a cadeia de certificados está correta, confiando assim em todos os certificados.

...
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();
...

Ao tentar se conectar a "https://www.myTrustedSite.com", o aplicativo pode aceitar facilmente um certificado emitido para "hackedserver.com". Agora, é possível que ele deixe vazar informações confidenciais dos usuários em uma conexão SSL interrompida com o servidor invadido.

Em algumas bibliotecas que usam conexões SSL, é possível desabilitar a verificação de certificados do servidor. Isso é equivalente a confiar em todos os certificados.

Exemplo 1: Este aplicativo desabilita explicitamente a verificação de certificados:

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

Ao tentar se conectar a um host válido, o aplicativo pode aceitar facilmente um certificado emitido para "hackedserver.com". Agora, é possível que ele deixe vazar informações confidenciais dos usuários em uma conexão SSL interrompida com o servidor invadido.

Em algumas bibliotecas que usam conexões SSL, o certificado do servidor não é verificado por padrão. Isso é equivalente a confiar em todos os certificados.

Exemplo 1: Este aplicativo não verifica explicitamente o certificado do servidor.

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

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

Ao tentar se conectar a example.com, esse aplicativo aceita prontamente qualquer certificado emitido pelo servidor. Potencialmente, esse aplicativo pode vazar informações confidenciais dos usuários em uma conexão SSL interrompida com o servidor invadido.

Em algumas bibliotecas que usam conexões SSL, o certificado do servidor não é verificado por padrão. Isso é equivalente a confiar em todos os certificados.

Exemplo 1: Este servidor tenta verificar conexões de cliente incorretamente:

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

Quando esse objeto https.Server é criado, a configuração requestCert é especificada como true, mas rejectUnauthorized não é definido, o que padroniza como false. Isso significa que, embora o servidor tenha sido criado com a intenção de verificar os clientes via SSL, as conexões ainda serão aceitas mesmo se o certificado não for autorizado com a lista de ACs fornecidas.

Exemplo 2: Este aplicativo tenta se conectar a um servidor via SSL:

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

Neste exemplo, uma vez que rejectUnauthorized foi definido como false, isso significa que os certificados não autorizados serão aceitos, e uma conexão segura com o servidor não identificado ainda será criada. Agora, é possível que ele deixe vazar informações confidenciais dos usuários em uma conexão SSL interrompida com o servidor invadido.

Em algumas bibliotecas que envolvem conexões SSL, o certificado do servidor não é verificado por padrão (ou pode ser explicitamente configurado para fazê-lo). Isso é equivalente a confiar em todos os certificados.

Exemplo 1: Este código configura o NSURLConnectionDelegate para aceitar qualquer certificado HTTPS:

implementation NSURLRequest (IgnoreSSL)

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

@end

Ao tentar conectar-se a um servidor protegido por SSL utilizando a implementação de NSURLRequest do Example 1, nenhum aviso ou erro resultará se o certificado solicitado do servidor for autoassinado (e, portanto, não verificado). Como resultado, o aplicativo potencialmente vazaria agora informações confidenciais do usuário por meio da conexão SSL quebrada.

Em algumas bibliotecas que usam conexões SSL, é possível desabilitar a verificação de certificados do servidor. Isso é equivalente a confiar em todos os certificados.

Exemplo 1: Esse aplicativo não verifica o certificado do servidor por padrão:

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

Ao tentar se conectar a um host válido, o aplicativo pode aceitar facilmente um certificado emitido para "hackedserver.com". Agora, é possível que ele deixe vazar informações confidenciais dos usuários em uma conexão SSL interrompida com o servidor invadido.

Em algumas bibliotecas que usam conexões SSL, é possível desabilitar a verificação de certificados do servidor. Isso é equivalente a confiar em todos os certificados.

Exemplo 1: Este aplicativo desabilita explicitamente a verificação de certificados:

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

Ao tentar se conectar a um host válido, o aplicativo pode aceitar facilmente um certificado emitido para "hackedserver.com". Agora, é possível que ele deixe vazar informações confidenciais dos usuários em uma conexão SSL interrompida com o servidor invadido.

Em algumas bibliotecas que envolvem conexões SSL, o certificado do servidor não é verificado por padrão (ou pode ser explicitamente configurado para fazê-lo). Isso é equivalente a confiar em todos os certificados.

Exemplo 1: Este código configura o NSURLConnectionDelegate para aceitar qualquer certificado 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)
    }
}

Ao tentar conectar-se a um servidor protegido por SSL utilizando a implementação de NSURLConnectionDelegate do Example 1, nenhum aviso ou erro resultará se o certificado solicitado do servidor for autoassinado (e, portanto, não verificado). Como resultado, o aplicativo potencialmente vazaria agora informações confidenciais do usuário por meio da conexão SSL quebrada.

Exemplo 2: Em uma classe NSURLSession, a validação de cadeia de SSL/TLS é manipulada pelo método delegado de autenticação do aplicativo, mas, em vez de fornecer credenciais para autenticar o usuário (ou seu aplicativo) no servidor, o aplicativo verifica as credenciais fornecidas pelo servidor durante o handshake SSL/TLS e informa o sistema de carregamento de URL se ele deve aceitar ou rejeitar essas credenciais. O seguinte código mostra um NSURLSessionDelgate que passa umaproposedCredential do desafio recebido de volta como uma credencial para a sessão, ignorando efetivamente a verificação do servidor:

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

As respostas HTTP(S) podem conter dados confidenciais, como cookies da sessão e tokens de API. O sistema de carregamento de URL armazenará em cache todas as respostas HTTP(S) para fins de desempenho, armazenando-as de forma descriptografada nos arquivos {app ID}/Library/Caches/com.mycompany.myapp/Cache.db*.

As respostas HTTP(S) podem conter dados confidenciais, como cookies da sessão e tokens de API. O sistema de carregamento de URL armazenará em cache todas as respostas HTTP(S) para fins de desempenho, armazenando-as de forma descriptografada nos arquivos {app ID}/Library/Caches/com.mycompany.myapp/Cache.db*.