oracular (7) random.7.gz

Provided by: manpages-ro_4.23.1-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
       ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ 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⟩.