Provided by: manpages-ro_4.27.0-1_all bug

NUME

       random - prezentare generală a interfețelor pentru obținerea aleatoriei

DESCRIERE

       Generatorul  de  numere  aleatoare  din  nucleu  se  bazează  pe  entropia colectată 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 degrabă decât pentru viteză.

       Următoarele interfețe oferă acces la ieșirile din nucleul CSPRNG:

       •  Dispozitivele /dev/urandom și /dev/random, ambele descrise în random(4). Aceste  dispozitive  au  fost
          prezente în Linux încă de la început și sunt disponibile și pe multe alte sisteme.

       •  Apelul  de sistem getrandom(2) specific Linux, disponibil începând cu Linux 3.17. Acest apel de sistem
          oferă acces fie la aceeași sursă ca și /dev/urandom (denumită sursa urandom în această pagină), fie la
          aceeași sursă ca și /dev/random (denumită sursa random în această  pagină).  Valoarea  implicită  este
          sursa  urandom;  sursa  urandom  este  selectată prin specificarea fanionului GRND_RANDOM la apelul de
          sistem; (funcția getentropy(3) oferă o interfață mai ușor portabilă pe lângă getrandom(2).)

   Inițializarea fondului de entropie
       Nucleul colectează biți de entropie din mediul  înconjurător.  Atunci  când  a  fost  colectat  un  număr
       suficient de biți aleatori, se consideră că fondul de entropie este inițializat.

   Alegerea sursei aleatorii
       Cu  excepția  cazului în care generați chei pe termen lung (și cel mai probabil nici atunci), probabil că
       nu ar trebui să citiți  de  pe  dispozitivul  /dev/random  sau  să  utilizați  getrandom(2)  cu  fanionul
       GRND_RANDOM.  În  schimb,  fie  citiți  de  pe dispozitivul /dev/urandom, fie utilizați getrandom(2) fără
       fanionul GRND_RANDOM. Algoritmii criptografici utilizați pentru sursa urandom sunt destul de conservatori
       și, prin urmare, ar trebui să fie suficienți pentru toate scopurile.

       Dezavantajul GRND_RANDOM și al citirilor din /dev/random  este  că  operația  se  poate  bloca  pentru  o
       perioadă  nedeterminată  de  timp. În plus, tratarea cererilor parțial îndeplinite care pot apărea atunci
       când se utilizează GRND_RANDOM sau când se citește din /dev/random crește complexitatea codului.

   Monte Carlo și alte aplicații de eșantionare probabilistică
       Utilizarea acestor interfețe pentru a furniza cantități mari de date pentru simulările  Monte  Carlo  sau
       pentru  alte  programe/algoritmi care efectuează eșantionări probabilistice va fi lentă. În plus, nu este
       necesar, deoarece astfel de aplicații nu au nevoie  de  numere  aleatoare  sigure  din  punct  de  vedere
       criptografic.  În  schimb,  utilizați  interfețele descrise în această pagină pentru a obține o cantitate
       mică de date pentru a alimenta un generator de numere pseudoaleatoare în spațiul utilizatorului, care  să
       fie utilizat de astfel de aplicații.

   Comparație între „getrandom”, „/dev/urandom” și „/dev/random”
       Tabelul  următor  rezumă  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 coloană a tabelului ia în considerare cazul care poate
       apărea la începutul perioadei de pornire, când fondul de entropie nu este încă inițializat.
       ┌───────────────┬──────────────┬────────────────┬────────────────────┐
       │ InterfațăFondComportamentComportamentul     │
       │               │              │ de blocareatunci când fondul │
       │               │              │                │ nu este încă       │
       │               │              │                │ disponibil         │
       ├───────────────┼──────────────┼────────────────┼────────────────────┤
       │ /dev/random   │ Blocarea     │ Dacă entropia  │ Blochează până     │
       │               │ fondului     │ este prea      │ când se adună      │
       │               │              │ mică, se       │ suficientă         │
       │               │              │ blochează până │ entropie           │
       │               │              │ când există    │                    │
       │               │              │ din nou        │                    │
       │               │              │ suficientă     │                    │
       │               │              │ entropie       │                    │
       ├───────────────┼──────────────┼────────────────┼────────────────────┤
       │ /dev/urandom  │ Ieșire       │ Nu blochează   │ Returnează ieșirea │
       │               │ CSPRNG       │ niciodată      │ de la un CSPRNG    │
       │               │              │                │ neinițializat      │
       │               │              │                │ (poate fi cu       │
       │               │              │                │ entropie scăzută   │
       │               │              │                │ și nepotrivită     │
       │               │              │                │ pentru             │
       │               │              │                │ criptografie)      │
       ├───────────────┼──────────────┼────────────────┼────────────────────┤
       │ getrandom()   │ La fel ca    │ Nu se          │ Blochează până     │
       │               │ /dev/urandom │ blochează      │ când este          │
       │               │              │ odată ce este  │ disponibil fondul  │
       │               │              │ disponibil     │                    │
       │               │              │ fondul         │                    │
       ├───────────────┼──────────────┼────────────────┼────────────────────┤
       │ getrandom()   │ La fel ca    │ Dacă entropia  │ Blochează până     │
       │ GRND_RANDOM/dev/random  │ este prea      │ când este          │
       │               │              │ mică, se       │ disponibil fondul  │
       │               │              │ blochează până │                    │
       │               │              │ când există    │                    │
       │               │              │ din nou        │                    │
       │               │              │ suficientă     │                    │
       │               │              │ entropie       │                    │
       ├───────────────┼──────────────┼────────────────┼────────────────────┤
       │ getrandom()   │ La fel ca    │ Nu se          │ EAGAIN             │
       │ GRND_NONBLOCK/dev/urandom │ blochează      │                    │
       │               │              │ odată ce este  │                    │
       │               │              │ disponibil     │                    │
       │               │              │ fondul         │                    │
       ├───────────────┼──────────────┼────────────────┼────────────────────┤
       │ getrandom()   │ La fel ca    │ EAGAIN dacă nu │ EAGAIN             │
       │ GRND_RANDOM + │ /dev/random  │ este           │                    │
       │ GRND_NONBLOCK │              │ disponibilă    │                    │
       │               │              │ suficientă     │                    │
       │               │              │ entropie       │                    │
       └───────────────┴──────────────┴────────────────┴────────────────────┘

   Generarea cheilor criptografice
       Cantitatea de material de  sămânță  necesară  pentru  a  genera  o  cheie  criptografică  este  egală  cu
       dimensiunea  efectivă  a  cheii. De exemplu, o cheie privată RSA sau Diffie-Hellman pe 3072 de biți are o
       dimensiune efectivă a cheii de 128 de biți (este nevoie de aproximativ  2^128  de  operații  pentru  a  o
       sparge),  astfel  încât  un  generator  de chei are nevoie doar de 128 de biți (16 octeți) de material de
       sămânță din /dev/random.

       În timp ce o anumită marjă de siguranță peste acest minim  este  rezonabilă,  ca  o  protecție  împotriva
       defectelor  din algoritmul CSPRNG, nicio primitivă criptografică disponibilă în prezent nu poate spera să
       promită mai mult de 256 de biți de securitate, astfel încât, dacă 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
       reînsămânțare  (nu mai puțin de un minut), acest lucru ar trebui considerat ca un semn că criptografia sa
       nu este implementată cu pricepere.

CONSULTAȚI ȘI

       getrandom(2), getauxval(3), getentropy(3), random(4), urandom(4), signal(7)

TRADUCERE

       Traducerea   în   limba   română   a   acestui   manual   a   fost   făcută   de   Remus-Gabriel    Chelu
       <remusgabriel.chelu@disroot.org>

       Această  traducere  este  documentație  gratuită;  citiți  Licența publică generală GNU Versiunea 3 sau o
       versiune  ulterioară  cu  privire  la  condiții  privind  drepturile  de  autor.   NU  se   asumă   NICIO
       RESPONSABILITATE.

       Dacă  găsiți  erori  în  traducerea  acestui manual, vă rugăm să trimiteți un e-mail la translation-team-
       ro@lists.sourceforge.net.

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