random(7)              Miscellaneous Information Manual              random(7)

NUME
       random - prezentare generala a interfe<?>elor pentru ob<?>inerea
       aleatoriei

DESCRIERE
       Generatorul de numere aleatoare din nucleu se bazeaza pe entropia
       colectata de la controlorii de dispozitiv <?>i de la alte surse de
       zgomot de mediu pentru a alimenta un generator de numere
       pseudoaleatoare securizat din punct de vedere criptografic (CSPRNG).
       Acesta este conceput pentru securitate, mai degraba decat pentru
       viteza.

       Urmatoarele interfe<?>e ofera acces la ie<?>irile din nucleul CSPRNG:

       o  Dispozitivele /dev/urandom <?>i /dev/random, ambele descrise in
          random(4). Aceste dispozitive au fost prezente in Linux inca de la
          inceput <?>i sunt disponibile <?>i pe multe alte sisteme.

       o  Apelul de sistem getrandom(2) specific Linux, disponibil incepand cu
          Linux 3.17. Acest apel de sistem ofera acces fie la aceea<?>i sursa
          ca <?>i /dev/urandom (denumita sursa urandom in aceasta pagina), fie
          la aceea<?>i sursa ca <?>i /dev/random (denumita sursa random in
          aceasta pagina). Valoarea implicita este sursa urandom; sursa
          urandom este selectata prin specificarea fanionului GRND_RANDOM la
          apelul de sistem; (func<?>ia getentropy(3) ofera o interfa<?>a mai
          u<?>or portabila pe langa getrandom(2).)

   Ini<?>ializarea fondului de entropie
       Nucleul colecteaza bi<?>i de entropie din mediul inconjurator. Atunci
       cand a fost colectat un numar suficient de bi<?>i aleatori, se
       considera ca fondul de entropie este ini<?>ializat.

   Alegerea sursei aleatorii
       Cu excep<?>ia cazului in care genera<?>i chei pe termen lung (<?>i cel
       mai probabil nici atunci), probabil ca nu ar trebui sa citi<?>i de pe
       dispozitivul /dev/random sau sa utiliza<?>i getrandom(2) cu fanionul
       GRND_RANDOM. In schimb, fie citi<?>i de pe dispozitivul /dev/urandom,
       fie utiliza<?>i getrandom(2) fara fanionul GRND_RANDOM. Algoritmii
       criptografici utiliza<?>i pentru sursa urandom sunt destul de
       conservatori <?>i, prin urmare, ar trebui sa fie suficien<?>i pentru
       toate scopurile.

       Dezavantajul GRND_RANDOM <?>i al citirilor din /dev/random este ca
       opera<?>ia se poate bloca pentru o perioada nedeterminata de timp. In
       plus, tratarea cererilor par<?>ial indeplinite care pot aparea atunci
       cand se utilizeaza GRND_RANDOM sau cand se cite<?>te din /dev/random
       cre<?>te complexitatea codului.

   Monte Carlo <?>i alte aplica<?>ii de e<?>antionare probabilistica
       Utilizarea acestor interfe<?>e pentru a furniza cantita<?>i mari de
       date pentru simularile Monte Carlo sau pentru alte programe/algoritmi
       care efectueaza e<?>antionari probabilistice va fi lenta. In plus, nu
       este necesar, deoarece astfel de aplica<?>ii nu au nevoie de numere
       aleatoare sigure din punct de vedere criptografic. In schimb,
       utiliza<?>i interfe<?>ele descrise in aceasta pagina pentru a ob<?>ine
       o cantitate mica de date pentru a alimenta un generator de numere
       pseudoaleatoare in spa<?>iul utilizatorului, care sa fie utilizat de
       astfel de aplica<?>ii.

   Compara<?>ie intre ,,getrandom", ,,/dev/urandom" <?>i ,,/dev/random"
       Tabelul urmator rezuma comportamentul diferitelor interfe<?>e care pot
       fi utilizate pentru a ob<?>ine caracterul aleatoriu. GRND_NONBLOCK este
       un fanion care poate fi utilizat pentru a controla comportamentul de
       blocare al getrandom(2). Ultima coloana a tabelului ia in considerare
       cazul care poate aparea la inceputul perioadei de pornire, cand fondul
       de entropie nu este inca ini<?>ializat.

       +--------------+-----------------+------------------+--------------------+
       |Interfa<?>a   | Fond            | Comportament de  | Comportamentul     |
       |              |                 | blocare          | atunci cand fondul |
       |              |                 |                  | nu este inca       |
       |              |                 |                  | disponibil         |
       +--------------+-----------------+------------------+--------------------+
       |/dev/random   | Blocarea        | Daca entropia    | Blocheaza pana     |
       |              | fondului        | este prea mica,  | cand se aduna      |
       |              |                 | se blocheaza     | suficienta         |
       |              |                 | pana cand exista | entropie           |
       |              |                 | din nou          |                    |
       |              |                 | suficienta       |                    |
       |              |                 | entropie         |                    |
       +--------------+-----------------+------------------+--------------------+
       |/dev/urandom  | Ie<?>ire CSPRNG | Nu blocheaza     | Returneaza         |
       |              |                 | niciodata        | ie<?>irea de la un |
       |              |                 |                  | CSPRNG             |
       |              |                 |                  | neini<?>ializat    |
       |              |                 |                  | (poate fi cu       |
       |              |                 |                  | entropie scazuta   |
       |              |                 |                  | <?>i nepotrivita   |
       |              |                 |                  | pentru             |
       |              |                 |                  | criptografie)      |
       +--------------+-----------------+------------------+--------------------+
       |getrandom()   | La fel ca       | Nu se blocheaza  | Blocheaza pana     |
       |              | /dev/urandom    | odata ce este    | cand este          |
       |              |                 | disponibil       | disponibil fondul  |
       |              |                 | fondul           |                    |
       +--------------+-----------------+------------------+--------------------+
       |getrandom()   | La fel ca       | Daca entropia    | Blocheaza pana     |
       |GRND_RANDOM   | /dev/random     | este prea mica,  | cand este          |
       |              |                 | se blocheaza     | disponibil fondul  |
       |              |                 | pana cand exista |                    |
       |              |                 | din nou          |                    |
       |              |                 | suficienta       |                    |
       |              |                 | entropie         |                    |
       +--------------+-----------------+------------------+--------------------+
       |getrandom()   | La fel ca       | Nu se blocheaza  | EAGAIN             |
       |GRND_NONBLOCK | /dev/urandom    | odata ce este    |                    |
       |              |                 | disponibil       |                    |
       |              |                 | fondul           |                    |
       +--------------+-----------------+------------------+--------------------+
       |getrandom()   | La fel ca       | EAGAIN daca nu   | EAGAIN             |
       |GRND_RANDOM + | /dev/random     | este disponibila |                    |
       |GRND_NONBLOCK |                 | suficienta       |                    |
       |              |                 | entropie         |                    |
       +--------------+-----------------+------------------+--------------------+
   Generarea cheilor criptografice
       Cantitatea de material de saman<?>a necesara pentru a genera o cheie
       criptografica este egala cu dimensiunea efectiva a cheii. De exemplu, o
       cheie privata RSA sau Diffie-Hellman pe 3072 de bi<?>i are o dimensiune
       efectiva a cheii de 128 de bi<?>i (este nevoie de aproximativ 2^128 de
       opera<?>ii pentru a o sparge), astfel incat un generator de chei are
       nevoie doar de 128 de bi<?>i (16 octe<?>i) de material de saman<?>a din
       /dev/random.

       In timp ce o anumita marja de siguran<?>a peste acest minim este
       rezonabila, ca o protec<?>ie impotriva defectelor din algoritmul
       CSPRNG, nicio primitiva criptografica disponibila in prezent nu poate
       spera sa promita mai mult de 256 de bi<?>i de securitate, astfel incat,
       daca un program cite<?>te mai mult de 256 de bi<?>i (32 de octe<?>i)
       din fondul aleatoriu al nucleului la fiecare invocare sau la un
       interval rezonabil de reinsaman<?>are (nu mai pu<?>in de un minut),
       acest lucru ar trebui considerat ca un semn ca criptografia sa nu este
       implementata cu pricepere.

CONSULTA<?>I <?>I
       getrandom(2), getauxval(3), getentropy(3), random(4), urandom(4),
       signal(7)

TRADUCERE
       Traducerea in limba romana a acestui manual a fost facuta de Remus-
       Gabriel Chelu <remusgabriel.chelu@disroot.org>

       Aceasta traducere este documenta<?>ie gratuita; citi<?>i Licen<?>a
       publica generala GNU Versiunea 3
       <https://www.gnu.org/licenses/gpl-3.0.html> sau o versiune ulterioara
       cu privire la condi<?>ii privind drepturile de autor.  NU se asuma
       NICIO RESPONSABILITATE.

       Daca gasi<?>i erori in traducerea acestui manual, va rugam sa
       trimite<?>i un e-mail la <translation-team-ro@lists.sourceforge.net>.

Pagini de manual de Linux 6.12    2 mai 2024                         random(7)