% !TEX root = ../thesis.tex

\chapter{Štatistické testovanie generátorov}
Pri používaní \acrshort{rng} môže dôjsť k jeho vnútorným zmenám. Na~statické overenie kvality generátorov náhodných čísel sa~používajú testy náhodnosti. Väčšina z~nich preveruje jednu alebo hneď niekoľko štatistických vlastností. Cieľom je~odhaliť periódu, respektíve nadväznosť bitov v~danej sekvencií dát. Pre používateľa sú~k~dispozícií vo~forme jednotlivých testov alebo štatistických testovacích sád. Takáto zbierka predstavuje viacero implementácií skúšok zoskupených dokopy, pripravených na~jednoduché použitie, modifikáciu a~vyhodnotenie. Najznámejšími~sú:
\begin{itemize}
	 \item\textbf{Dieharder}\cite{dieharder},
	 \item\textbf{NIST STS}\cite{niststs} -- z~ang. \textit{The NIST Statistical Test Suit}.
\end{itemize}
Okrem vyššie uvedených je však možné vyhľadať, vytvoriť, a aj upraviť, respektíve optimalizovať rôzne implementácie štatistických testov. Dôkazom toho je aj vznik modifikovanej NIST testovacej sady -- \cite{fasterniststs}. Podľa vyjadrení autorov uvedeného projektu sa im podarilo zefektívniť rýchlosť testovania o vyše 50 percent v porovnaní s originálom.

Je však nutné si uvedomiť, že úspešné absolvovanie ľubovoľného počtu štatistických testov nezabezpečuje kryptografickú bezpečnosť daného generátora. Dôvodom je, že niektoré z nástrojov na produkciu náhodných dát môžu byť pripravené tak, aby boli úspešné pri exekúcii týchto testov. Avšak platí, že ak má byť \acrshort{rng} označený za \acrshort{csprng}, tak musí úspešne zvládnuť testovanie štatistickými testami.

\section{Testovacia zbierka Dieharder}
Prvá zo spomenutých sád vznikla v~roku 2003 a~je aj~naďalej udržiavaná. Slúži na testovanie konkrétnych \acrshort{rng}s. Teda ak by sme uvažovali o~použití tejto testovacej zbierky, tak pre správnosť postupu by bolo nutné aplikovať testovanie na \acrshort{aes}-e v~režime, ktorý používa operačný systém Windows na produkciu náhodných dát. Z vyššie uvedených dôvodov charakterizujeme túto sadu veľmi stručne.

Aktuálna verzia -- 3.31.1, pozostáva~z~:
	\begin{itemize}
		\item 17 Diehard,
		\item  3 NIST STS, 
		\item 10 testov, autora tejto zbierky -- \textit{Róberta G. Brown-a}.
	\end{itemize}
Podrobnejší opis týchto testov je~dostupný online\footnote{https://sites.google.com/site/astudyofentropy/background-information/the-tests/dieharder-test-descriptions}$^{,}$\footnote{https://en.wikipedia.org/wiki/Diehard\_tests}. 
Inštalácia sady je jednoduchá najmä v prostredí OS Linux. Realizuje ju príkaz: \textbf{sudo apt-get install -y dieharder}\footnote{Príkaz pre distribúciu Ubuntu.}. V~prostredí systému Windows je potrebná zložitejšia konfigurácia. 

\section{NIST -- Štatistická testovacia sada}\label{nist} 
Tento balíček bol vytvorený inštitúciou NIST. Pozostáva z 15 testov. Slúžia na overenie kvality výstupných dát z hardvérových, a aj softvérových generátorov náhodných čísel. V~súčasnosti sa práve táto zbierka používa aj pri testovaní \acrshort{csprng}. Na rozdiel od spomenutej kolekcie \textit{Dieharder} táto zbierka vyšla s podrobnou dokumentáciou \cite{niststs}. Uvádzame stručný opis metód a použitých testov.

\subsection{Obsah sady a opis implementovaných testov}
Sada je pre používateľa dostupná vo forme archívu -- \uv{\textbf{sts-2.1.2.zip}}\footnote{Dostupné online: https://csrc.nist.gov/CSRC/media/Projects/Random-Bit-Generation/do-cuments/sts-2\_1\_2.zip}. Jeho obsahom sú implementácie štatistických testov v~jazyku C. \textbf{Makefile} na jednoduché vytvorenie spustiteľného programu a príklady vstupných dát z rôznych typov generátorov. Následné spustenie je opísané v \cite[kap. 5.6]{niststs} a pomocou ukážky \ref{sts}.

\subsubsection*{Opis testov štatistickej sady:} 
\begin{enumerate}
	\item \textbf{Frekvenčný test -- \textit{The Frequency/Monobit Test}\cite[kap. 2.1]{niststs}} 
	
	Výsledok je určený pomerom jednotkových a nulových bitov v danej testovanej sekvencii. Úspešný je vtedy, ak sa obsah jednotiek v našich dátach blíži k $\frac{1}{2}$ z celkového počtu. Odporúčaná dĺžka testovanej postupnosti je minimálne 100 bitov. Úspešné zvládnutie tohto testu je nutnou podmienkou pre ďalšie pokračovanie testovania.
	\item \textbf{Blokový frekvenčný test -- \textit{Frequency Test within a Block}\cite[kap. 2.2]{niststs}}
	
	Podobný prvému zo spomenutej sady. Namiesto celej testovacej sekvencie dát dochádza k frekvenčnému testu M-bitových blokov. Úspešný je vtedy, keď sa výsledný pomer rovná  $\frac{M}{2}$, pričom M je počet bitov jedného bloku. Obdobne aj v tomto prípade sa odporúča testovať minimálne 100 bitovú  postupnosť. 
	\item \textbf{Test rovnakých reťazcov -- \textit{Run Test}\cite[kap. 2.3]{niststs}}
	
	Zameraný na celkový počet po sebe idúcich neprerušených a rovnakých bitov -- tzv. \textbf{behov}. Cieľom tohto testu je overiť rôznorodosť striedajúcich sa sekvencií pri generovaní. Odporúča sa aplikovať na sekvencie s dĺžkou minimálne 100 bitov
	\item \textbf{Test najdlhšej sekvencie jednotiek v bloku -- \textit{Test for the longest Run of Ones in a Block}\cite[k. 2.4]{niststs}}
	
	Zameraný na najdlhší beh v M-bitových blokoch. Má za úlohu overiť, či vygenerovaná najväčšia sekvencia je v súlade s najdlhšou sériou, aká sa očakáva, resp povoľuje v náhodnej sekvencii bitov\footnote{Povolený počet jednotiek závisí od veľkosti testovanej sekvencie}. Odporúča sa aplikovať test na minimálne 128 bitov náhodnej postupnosti. \footnote{V tomto prípade sa dovoľuje maximálne 8, po sebe idúcich, jednotkových bitov.} 
	\item \textbf{Test série binárnych matic -- \textit{Binary Matrix Rank Test}\cite[kap. 2.5]{niststs}}
	
	Zameraný na poradie disjunktných\footnote{Disjunktné množiny sú také, ktoré nemajú žiaden spoločný prvok} submatíc celej testovacej sekvencie. Overuje lineárne závislosti medzi podreťazcami s pevnými veľkosťami. Tento test je obdobne súčasťou sady Dieharder. Pre správne fungovanie je minimálna dĺžka sekvencie stanovená na 38 912 bitov.
	\item \textbf{Test diskrétnej Fourierovej transformácie -- \textit{Discrete Fourier Transform (Spectral) Test}\cite[kap. 2.6]{niststs}}
	
	Zameraný na výšky vrcholov -- \textbf{amplitúd}, jednotlivých bitov testovanej postupnosti v diskrétnej Fourierovej transformácii\footnote{https://cs.wikipedia.org/wiki/Fourierova\_transformace}. Cieľom je detekcia periodických znakov, ktorá by naznačovala odchýlku od predpokladu náhodnosti. Zisťujú sa prahové hodnoty\footnote{Prahová hodnota -- krajná, resp. hraničná hodnota. Získava sa prahovaním. Viac informácií o tejto metóde je dostupných v dokumente \cite[k. 1.3]{prahovanie}} 
 	95\% znakov a zvyšných 5\% testovanej sekvencie. Následne sa overuje, či nedochádza k významnej odlišnosti medzi týmito hodnotami. 1 000 bitov sa odporúča ako minimálna veľkosť postupnosti. 
	\item \textbf{Test neprekrývajúcich sa vzorov -- \textit{Non-overlapping Template Matching Test}\cite[kap. 2.7]{niststs}}
	
	Zameraný na počet vopred určených bitov v testovanom reťazci -- tzv. okne. Cieľom je detegovať generátor, ktorý produkuje veľa neperiodického vzoru. Test používa m-bitové okno na vyhľadanie konkrétneho m-bitového vzoru. Ak ho nenájde, nastane posun okna o jednu bitovú pozíciu. Ak sa nájde, okno sa resetuje na bity po nájdenom vzore a vyhľadávanie pokračuje. Nemá odporúčanú dĺžku vstupnej postupnosti. Parametre pre tento test sa vypočítajú na základe požiadavky.
	\item \textbf{Test prekrývajúcich sa vzorov -- \textit{Overlapping Template Matching Test}\cite[kap. 2.8]{niststs}}
	
	Pracuje na rovnakom princípe ako 7. test. Rozdiel je len pri zhode vzoru s oknom. V tomto prípade sa okno posúva o jeden bit a následne pokračuje prehľadávanie.
	\item \textbf{Mauerov \uv{univerzálny štatistický} test -- \textit{Maurer's \uv{Universal Statistical} Test}\cite[kap. 2.9]{niststs}}
	
	Zameraný na počet bitov medzi zhodnými vzormi. Overuje, či je možné danú postupnosť komprimovať bez straty informácií. Ak je možná veľká kompresia, tak daná sekvencia sa nepovažuje za náhodnú. Vstupná postupnosť môže mať variabilnú dĺžku. Odporúča sa aplikovať na minimálne 1 000 000-bitovú postupnosť.
	\item \textbf{Test lineárnej zložitosti -- \textit{Linear Complexity Test}\cite[k. 2.10]{niststs}}
	
	Zameraný na dĺžku posuvného registra s lineárnou spätnou väzbou -- \acrshort{lfsr}\footnote{Výstup tohto registra je lineárne závislý od jeho počiatočného stavu a predchádzajúcich výstupov. Používa sa napríklad v PRNG a prúdových šifrách.}. Cieľom je zistiť, či je daná postupnosť dostatočne zložitá, aby sa mohla považovať za náhodnú. Platí, že dlhšie \acrshort{lfsr}s spĺňajú tento predpoklad. 
	\\
	\item \textbf{Test Sérií -- \textit{Serial Test}\cite[kap. 2.11]{niststs}}
	
	Zameraný na frekvenciu všetkých možných prekrývajúcich sa m-bitových vzorov v celej testovanej postupnosti. Cieľom je zistiť, či počet výskytov je približne rovnaký, ako by mal byť v náhodnej sekvencii. Tá by mala byť rovnomerná\footnote{Rovnomernosť, resp. uniformita, náhodnej sekvencie znamená, že každý m-bitový vzor ma rovnakú pravdepodobnosť objaviť sa, ako ktorýkoľvek iný.}. Vyžaduje sa zvoliť m také, pre ktoré platí $m<[log_2 n]-2$. Veľkosť vstupnej sekvenciu v bitoch reprezentuje premenná $n$.
	\item \textbf{Približný test Entropie -- \textit{Approximate Entropy Test}\cite[kap. 2.12]{niststs}}
	
	Podobný ako Test Sérií. Zameraný na frekvenciu všetkých možných prekrývajúcich sa vzorov s dĺžkou m-bitov. Porovnanie sa aplikuje na frekvencie dvoch po sebe nasledujúcich blokov, ktoré sa prekrývajú. Výsledok sa následne porovná s ekvivalentom pre náhodnú sekvenciu. Vyžaduje sa zvoliť m také, pre ktoré platí $m<[log_2 n]-5$. Veľkosť vstupnej sekvenciu v bitoch reprezentuje premenná $n$.
	\item \textbf{Test kumulatívnych súčtov -- \textit{Cumulative Sums Test}\cite[kap. 2.13]{niststs}}
	
	Zameraný na maximálnu odchýlku od nuly pri kumulatívnom súčte všetkých bitov. Pri~tomto postupnom hromadnom sčítaní predstavujú jednotkové bity kladné jednotky. Nuly na druhej strane záporné. Cieľom testu je určiť, či takýto kumulatívny súčet testovaných dát zodpovedá náhodnej sekvencii. Test je úspešný, ak sa výsledok sčítania blíži k nule. Odporúča sa, aby každá testovaná sekvencia mala minimálnu dĺžku 100 bitov.  
	\item \textbf{Test náhodných návštev -- \textit{Random Excursions Test}\cite[kap. 2.14]{niststs}}
	
	Zameraný na počet cyklov, ktoré majú presne K náhodných návštev v kumulatívnom súčte. Všetky cykly majú dĺžku zvolenú náhodne. Cieľom je zistiť či sa počet návštev odlišuje od hodnoty platnej pre náhodné dáta. Test pozostáva z 8 čiastočných testov. Každý otestuje jeden zo stavov: -~4, -~3, -~2, -~1, 1, 2, 3, 4. Úspešný je iba ak dáta uspejú vo všetkých čiastočných testoch. Odporúča sa testovať postupnosť s minimálnou dĺžkou 1 000 000 bitov.  
	\item \textbf{Test variantov náhodných  návštev -- \textit{Random Excursions Variant Test}\cite[kap. 2.15]{niststs}}
	
	Zameraný na celkový počet návštev jednotlivých stavov pri kumulatívnom súčte. Pozostáva z 18 testov. Postupne sa testujú stavy: -~9, -~8, ..., -~1, 1, ..., 8, 9. Odporúčaná minimálna veľkosť vstupu je rovnaká ako v 14. teste. 	
\end{enumerate}

\subsection{Vyhodnotenie výsledkov štatistických testov}
Nasledujúce vety vznikli parafrázou \cite[kap. 1.1.5]{niststs}. Testovanie pomocou sady je založené na overení dvoch predpokladov, tzv. \textbf{nulovej} a \textbf{alternatívnej} hypotézy. Prvá z uvedených, ozn. $H_0$, tvrdí, že testovaná postupnosť je náhodná. Druhú definujeme ako inverznú voči nulovej, teda výstup z RNG je nenáhodný. Len jeden z týchto predpokladov je prijatý v priebehu aplikácie sady. V~súvislosti s týmto postupom môže dôjsť k 2 typom chýb v priebehu testovania.
\begin{enumerate}
	\item Sekvencia je náhodná, ale $H_0$ nebola akceptovaná.
	\item Postupnosť nie je náhodná, avšak nulová hypotéza je prijatá.
\end{enumerate}  
Pravdepodobnosť, že dôjde k~prvému zo~spomenutých dejov definuje pojem -- \textbf{hladina významnosti}, označíme $\alpha$. Jej~veľkosť závisí od~konkrétneho štatistického testu. Typicky sa volí z~intervalu  $[0.001;0.01]$

Na vyhodnotenie uvedených predpokladov dochádza pri~každom teste k~porovnaniu \textbf{výslednej štatistickej} -- $S$,\footnote{Hodnota získaná aplikovaním daného testu na~naše dáta} a~\textbf{kritickej} hodnoty, ďalej \acrshort{cv}\footnote{Z~ang. Critical Value}. Každý z~testov má definované štatistické hodnoty, na~základe ktorých môžeme prijať alebo odmietnuť $H_0$.  \acrshort{cv} je hodnota získaná štatistickým rozdelením hodnôt. Platí, že predstavuje výsledok testu, ktorý pochádza na~99\% z~nenáhodnej sekvencie testovaných dát. Inými slovami, predstavuje hodnotu, pri~ktorej už neakceptujeme $H_0$ ako pravdivé. Program vytvorí výpis s~medzi-výpočtami pre každý test a~zároveň aj finálny výsledok testu. Používateľ si však môže všimnúť tzv. \textbf{pravdepodobnostné hodnoty} -- \textbf{\textit{$p-values$}}. Získa ich výpočtom pravdepodobnosti z~vyššie uvedeného porovnania. Ten reprezentuje pravdepodobnosť, vygenerovania lepšej náhodnej postupnosti dát ako by zvládol dokonalý RNG. Pri úspešnom teste platí \eqref{p-value}. \\
Nech   
\begin{equation*}
	X = p-values = P(S),
\end{equation*}
potom,
\begin{equation}\label{p-value}	  
	(X \in (\alpha < X \geq 1)) \Leftrightarrow (H_0 = pravda).
\end{equation}
\subsection{Doba vykonania testovacej sady}
Na meranie dĺžky sme modifikovali zdrojové kódy uvedenej sady. Použité bolo Windows rozhranie na meranie času -- \textbf{QueryPerformanceCounter()}. Taktiež sme zistili počet cyklov jednotlivých testov vzhľadom na veľkosti vstupov. K tomu nám dopomohli inštrukcie \textbf{RDTSC} a \textbf{RDTSCP}. Opis použitých metód je obsahom kapitoly \ref{merania}. 

Experimentálne výsledky sú znázornené v~tabuľke \ref{ststimes}. Výsledná doba vykonania daného testu je závislá na~veľkosti sekvencie. Pre celkový čas platí \eqref{totaltime}. Ak~by sme si vyhradili procesor iba pre nás, tak potom jednotlivé časy $t_i$ by boli konštantné. Dôvodom je deterministický charakter procesu. Tento úkon však nie je v používateľskom režime možný. Uvedený vzťah ráta s týmto faktom.\\  
\\Nech

	$n$  -- veľkosť vstupnej testovacej postupnosti,
	
	$t_i$ -- doba aplikovania všetkých testov na n-bitovú sekvenciu,
	
	$m$	-- počet testovaných prúdov s veľkosťou n, 
	
	$T$ -- výsledný čas celého testovania.\\
Potom
\begin{equation}\label{totaltime}	  
	T = \sum_{i=1}^{m}t_i .
\end{equation}


\begin{table}[!ht]
	\centering

		\begin{tabular}{ c|c|c|c|c  }

		\multicolumn{5}{c}{\bfseries Veľkosť vstupnej testovanej sekvencie  } \\
		\multirow{2}*{\bfseries Test č.} & \multicolumn{2}{c}{\bfseries 122kB $\approx$ 1 000 000 b } & \multicolumn{2}{c}{\bfseries 1,165GB $\approx$ 10 000 000 000 b   }\\ 
		& \bfseries ČAS [s]   & \bfseries CYKLY
	& \bfseries ČAS [s]  & \bfseries CYKLY\\
	\hline
		 1 & 0,004 055 &\multicolumn{1}{r|}{ 11 730 471} &\multicolumn{1}{r|}{ 5,387 021} & \multicolumn{1}{r}{15 593 089 692} \\
		2 & 0,002 740 &\multicolumn{1}{r|}{ 7 921 031} & \multicolumn{1}{r|}{3,591 694} &\multicolumn{1}{r}{10 396 392 294} \\
		3 & 0,009 644 & \multicolumn{1}{r|}{27 907 135} & \multicolumn{1}{r|}{13,367 284} & \multicolumn{1}{r}{38 692 505 860} \\
		4 & 0,014 938 & \multicolumn{1}{r|}{43 230 329} & \multicolumn{1}{r|}{21,562 572} &\multicolumn{1}{r}{62 414 330 729} \\
		5 & 0,007 866 & \multicolumn{1}{r|}{22 760 418} & \multicolumn{1}{r|}{10,895 430} & \multicolumn{1}{r}{ 31 537 547 299} \\
		6 & 0,074 364 & \multicolumn{1}{r|}{215 241 654} & \multicolumn{1}{r|}{104,454 277} & \multicolumn{1}{r}{302 350 042 366} \\
		7 & 0,226 567 & \multicolumn{1}{r|}{655 801 389} & \multicolumn{1}{r|}{0,036 371} & \multicolumn{1}{r}{105 257 157} \\
		8 & 1,763 558 & \multicolumn{1}{r|}{5 104 725 551} & \multicolumn{1}{r|}{2 485,426 270} &\multicolumn{1}{r}{719 423 6071 645} \\
		9 & 0,056 390 & \multicolumn{1}{r|}{163 214 697} & \multicolumn{1}{r|}{78,888 596} & \multicolumn{1}{r}{228 348 426 960} \\
		10 & 0,045 201 & \multicolumn{1}{r|}{130 830 194} & \multicolumn{1}{r|}{67,123 001} & \multicolumn{1}{r}{194 292 108 778} \\
		11 & 0,203 056 & \multicolumn{1}{r|}{587 748 800} & \multicolumn{1}{r|}{285,328 339} & \multicolumn{1}{r}{825 902 376 471} \\
		12 & 0,004 447 & \multicolumn{1}{r|}{12 862 109} & \multicolumn{1}{r|}{10,411 473} & \multicolumn{1}{r}{30 136 705 606} \\
		13 & 0,005 211 & \multicolumn{1}{r|}{15 068 574} & \multicolumn{1}{r|}{76,817 490} & \multicolumn{1}{r}{222 353 456 121} \\
		14 & 0,564 533 & \multicolumn{1}{r|}{1 634 064 740} & \multicolumn{1}{r|}{781,071 777} & \multicolumn{1}{r}{2 260 865 638 374} \\
		15 & 3,703 921 & \multicolumn{1}{r|}{10 721 233 139} & \multicolumn{1}{r|}{5 222,643 066} & \multicolumn{1}{r}{15 117 297 898 720} \\
		\hline
		\centering\bfseries	Sumár & 6,686501 & 19 354 524 033 & 9 167,004 883 & 26 534 522 105 621 \\
	\end{tabular}

\caption{Meranie testovania sady pomocou konfigurácie A }\label{ststimes}
\end{table}
\subsubsection{Odporúčanie pri spustení}
Na spustenie sady je potrebná inicializácia. Používateľ ju realizuje vstupmi z príkazového riadku. Zdrojový kód \ref{sts}, znázorňuje tento úkon. Veľkosť otestovaných dát pomocou takejto konfigurácie je 11,92 MB\footnote{1 000 000 b $*$ 100 $=$ 100 000 000 b $\approx$ 11,92MB}. 

Pre optimálne fungovanie všetkých testov je ideálnejšie použiť veľkosť vstupnej sekvencie rovnú 1 000 000 bitov teda približne 122kB. Následne pri väčšom objeme testovaných dát zvolíme vyšší počet prúdov. Týmto postupom zamedzíme vzniku chýb pri alokovaní potrebnej pamäte a vykonané testy poskytnú kvalitnejšie výsledky. 

\noindent
\begin{minipage}{\linewidth} 	
	%\section{Výpis kódu jazyka C}
	\begin{lstlisting}[frame=single,
		numbers=left,
		language=bash,
		caption={Ukážka spustenia sady NIST STS}\label{sts},
		basicstyle=\ttfamily\small, keywordstyle=\color{black}\bfseries,][ht!]		
> ./assess.exe 1000000   // size of random sequence in bits
> 0                      // apply tests on input file
> myRandomDataFile.bin   // name of file with random numbers
> 1                      // apply all tests
> 0                      // no changes of default tests values 
> 100                    // number of bit streams
> 1                      // choosen bin format of input file		
	\end{lstlisting}
\end{minipage}\\

\chapter{Metodika testovania dát a merania rozhraní}\label{merania}
Pred samotným generovaním dát bolo nutné zvoliť si~meracie a testovacie metódy. V~tejto kapitole si ich popíšeme.

Implementáciu rozhraní sme realizovali v programovacom jazyku C. Preklad do strojového kódu zabezpečí prekladač \acrshort{gcc} vo verzii 10.2.0. \textbf{Overenie kvality dát} vykonáme pomocou NIST STS, opísanej v podkapitole \ref{nist}.
Pri experimentálnych meraniach implementácií RNG rozhraní sme sa zamerali na tri údaje:
\begin{itemize}
	\item čas exekúcie samotnej implementácie -- \textbf{$T_A$}, 
	\item dobu vykonania, vrátane bežných úkonov\footnote{Ukladanie dát, overenie úspešnosti generovania, ...} -- \textbf{$T_B$}
	\item priemerný počet cyklov API -- \acrshort{anc}\footnote{Predstavuje priemernú hodnotu. Získa sa ako pomer súčtu všetkých vykonaných cyklov a počtu opakovaní volania testovanej funkcie. Vypočítané iba v prípade $T_A$}
\end{itemize}
Pomocou týchto nameraných hodnôt sme vypočítali priepustnosť dát. Použili sme vzťah \eqref{priepustnost}.\\
Nech

	$_X=\{A,B\}$,

	$T_X$ -- čas zvoleného procesu,
	
	$NI$ -- počet opakovaných volaní\footnote{Z ang. \textit{Number of iterations}},
	
	$BS$  -- veľkosť zásobníka\footnote{Z ang. \textit{Buffer Size}},

	$V_D = NI*BS$ -- celkový objem vygenerovaných dát,

	$P_X$ -- priepustnosť procesu,\\
potom,
\begin{equation}\label{priepustnost}
	P_X = \frac{V_D}{T_X} 
\end{equation}

Uvedené experimenty boli aplikované na~troch zariadeniach. Špecifikáciu týchto prenosných počítačov znázorňuje tabuľka \ref{pc}. Všetky notebook-y sme počas testovania pripojili do elektrickej siete. Režim napájania sme zmenili na \uv{Vysoký výkon}.

\textbf{Označenia} hodnôt a~meracích nástrojov, ktoré vznikli v~tejto kapitole \textbf{sú použité pri~interpretácii výsledkov}.


\begin{table}[!ht]
	\centering
	\resizebox{\textwidth}{!}{%
	\begin{tabular}{c|c|c|c} 
		\multirow{2}{*}{\bfseries Komponenty}&\multicolumn{3}{c}{ \bfseries Konfigurácia}  
		\\ 
					& \bfseries{A} -- ASUS TUF A15  
					& \bfseries{B} -- ASUS Vivo15  
					& \bfseries{C} -- LENOVO IdeaPad
		\\\hline\hline
		\bfseries Model &  F506IU-AL006T
						&  X510UN-BQ148R 
						&  S540-15IML
		\\
		\bfseries Verzia OS &  Win 10 Home; 64-bit.; v.20H2 
							&  Win 10 Pro; 64-bit.; v.2004 
							& Win 10 Home; 64-bit.; v. 20H2 
    	\\
    	\bfseries Zostava OS &19042.964
    						 &19041.928
    						 &19042.985 
    	\\
		\bfseries CPU& AMD Ryzen 7 Mobile 4800H
				 	 & Intel Core i5-8250U
					 & Intel Core i5-10210U 
		\\
		\bfseries RAM&16 GB DDR4 2x1600 MHz 
	  			 	 & 8 GB DDR4 1x2400 MHz
	  			 	 & 8 GB DDR4 2x1200 MHz
		\\
		\bfseries Úložisko&SSD OM8PCP3512F-AB
	 				  	  &HDD MQ04ABF100
	 				  	  &SSD SSDPEKNW512G8L 
		\\
	\end{tabular}
	}
\caption{Technická špecifikácia použitých počítačov}\label{pc}
\end{table}

V~tomto bode treba spomenúť určitú odchýlku experimentálnych meraní od skutočných hodnôt. Najväčším faktor, ktorý mohol spôsobiť chybu merania sú prerušenia operačného systému. \footnote{Viď. napríklad elapsedTime v \ref{qpc}}. Uvedenému procesu je možné sa vyhnúť jedine implementáciou modulu pre prácu v~režime jadra. Následne by sme si vyhradili procesor pre vlastné účely. Kladom módu by mohol byť aj menší počet inštrukcií potrebných na vykonanie funkcionality. S týmto postupom sa však používateľ často nestretáva. Uvedený fakt je dôvodom, prečo sme sa pri meraniach zamerali iba na~beh rozhraní v~používateľskom režime. Pripomeniem však, že rozhrania v~oboch režimoch poskytujú \textbf{identické služby}.


\section{Časové meranie rozhraní}
Pri meraní dĺžky behu rozhrania sme implementovali Windows API:
\begin{itemize}
	\item \verb|QueryPerformanceCounter()| --\acrshort{qpc} \cite{qpc}, 
	\item \verb|QueryPerformanceFrequency()| --\acrshort{qpf} \cite{qpf}.
\end{itemize}
Informácie o funkciách sú dostupné vo forme webovej dokumentácie \cite{measure}. Použitie týchto rozhraní pri meraní znázorňuje zdrojový kód \ref{qpc}. Uvedeným postupom dokážeme odmerať čas vykonania algoritmu s presnosťou nanosekúnd\footnote{API je možné implementovať s presnosťou piko-sekúnd. Viď \cite[Using QPC in native code]{measure}}. Presnosť metódy sa dá overiť jednoducho. Napríklad pomocou funkcie \verb|Sleep()|\footnote{Sleep(1000) reprezentuje jednu sekundu}. Stačí ju vložiť do priestoru merania.

\noindent
\begin{minipage}{\linewidth} 	
	%\section{Výpis kódu jazyka C}
	\begin{lstlisting}[frame=single,
		numbers=left,
		caption={Ukážka použitia QPC/QPF}\label{qpc},
		basicstyle=\ttfamily\small, keywordstyle=\color{black}\bfseries,]		
#include<windows.h>
#define TIMER_INIT \
LARGE_INTEGER frequency; \
LARGE_INTEGER t1,t2; \
double elapsedTime; \
QueryPerformanceFrequency(&frequency);

// Use to start the performance timer 
#define TIMER_START QueryPerformanceCounter(&t1);
// Use to stop the timer
#define TIMER_STOP \
QueryPerformanceCounter(&t2); \
elapsedTime=(double)(t2.QuadPart-t1.QuadPart)/frequency.QuadPart; 
int main(){
	TIMER_INIT
	{TIMER_START
		functionMeasurment(); // code for measurment
		TIMER_STOP}
	printf("Time of execution: %f sec\n", elapsedTime);
}		
	\end{lstlisting}
\end{minipage}\\
  
\subsubsection{Odporúčanie pri pretypovaní dát}
V jazyku C môže pri pretypovaní dát dochádzať k zmene poradia vygenerovaných reťazcov. Dôvodom je zmena endianity\footnote{\url{https://sk.wikipedia.org/wiki/Endianita}}, respektíve uloženia dát v pamäti. S týmto problémom sme sa stretli pri zmene z \textbf{unsigned int} na \textbf{unsigned char}. Dáta v pamäti boli uložené metodikou malý endián, ale správne poradie vygenerovaných dát reprezentoval veľký endián. V~tomto prípade bolo nutné vykonať konverziu endianity. Použili sme na to funkcie znázornené pomocou zdrojového kódu \ref{endian}. 

\noindent
\begin{minipage}{\linewidth} 	
	%\section{Výpis kódu jazyka C}
	\begin{lstlisting}[frame=single,
		numbers=left,
		caption={Ukážka pretypovania premenných}\label{endian},
		basicstyle=\ttfamily\small, keywordstyle=\color{black}\bfseries,]		
#include<stdio.h>	
#define IS_BIG_ENDIAN (!*(unsigned char *)&(uint16_t){1})
int main (){
	unsigned int a = 2343352;
	unsigned char b;
	if(!IS_BIG_ENDIAN)
	castUintToByte(a,b);
	else b=(unsigned char)a;
	printf("%lu",b);
	return 0;
}	
	\end{lstlisting}
\end{minipage}\\


\section{Meranie počtu cyklov rozhraní}
Obdobne sme sa zamerali aj na~počet cyklov rozhraní. Tento údaj nám z pohľadu dlhodobého vývoja predstavuje kvalitnejšiu informáciu ako čas vykonania. Na základe týchto údajov vieme určiť napríklad či v priebehu času došlo k zefektívneniu algoritmov  rozhrania\footnote{Zmenší sa počet cyklov, potrebných na vykonanie.}. Ďalším príkladom je určenie pomeru prerušení  \acrshort{os} a mnoho iných.
Meranie sme prvotne realizovali pomocou funkcie \textbf{\textit{cpucycles()}}\footnote{Funkcia prebraná z git archívu:  \url{https://github.com/newhopecrypto/newhope/tree/master/ref}}. Zdrojový kód \ref{git}, ju definuje. Táto metóda však neposkytovala dostatočne kvalitné výsledky.

\noindent
\begin{minipage}{\linewidth} 	
	%\section{Výpis kódu jazyka C}
	\begin{lstlisting}[frame=single,
		numbers=left,
		caption={Meranie počtu cyklov pomocou funkcie cpucycles()},label=git,
		basicstyle=\ttfamily\small, keywordstyle=\color{black}\bfseries,]		
int64_t cpucycles(void)
{
	uint64_t result;
	__asm__ volatile(".byte 15;.byte 49;shlq $32,
	%%rdx;orq %%rdx,%%rax"
	: "=a" (result) ::  "%rdx");
	return result;
}
	\end{lstlisting}
\end{minipage}\\

Meranie počtu vykonaných cyklov sme, kvôli tomuto faktoru, uskutočnili podľa metód v~Intel dokumente \cite[kap.3.2.1]{intelrd}. Ukážkou aplikovaného riešenia je kód \ref{cycles}.

\noindent
\begin{minipage}{\linewidth} 	
	%\section{Výpis kódu jazyka C}
	\begin{lstlisting}[frame=single,
		numbers=left,
		caption={Meranie počtu cyklov Intel metódou},label=cycles,
		basicstyle=\ttfamily\small, keywordstyle=\color{black}\bfseries,]	
#include <stdio.h>

//cpucyclesS -- Start measure	
static __inline__ uint64_t cpucyclesS(){
	unsigned cycles_low, cycles_high;
	__asm__ volatile ("CPUID\n\t"
	"RDTSC\n\t"
	"mov %%edx, %0\n\t"
	"mov %%eax, %1\n\t": "=r" (cycles_high), "=r" (cycles_low)::
	"%rax", "%rbx", "%rcx", "%rdx");
	return  (((uint64_t)cycles_high << 32) | cycles_low );
}
//cpucyclesE -- End measure
static __inline__ uint64_t  cpucyclesE(){
	unsigned cycles_low, cycles_high;
	__asm__ volatile ("RDTSCP\n\t"
	"mov %%edx, %0\n\t"
	"mov %%eax, %1\n\t"
	"CPUID\n\t": "=r" (cycles_high), "=r" (cycles_low)::
	"%rax", "%rbx", "%rcx", "%rdx");
	return (((uint64_t)cycles_high << 32) | cycles_low );
}
int main(){
	uint64_t tick,tock;		
	tick=cpucyclesS();
	codeForMeasurment();
	tock= cpucyclesE() - tick; 
	printf("Executed: %llu cycles\n", tock);
	return 0;
}
	\end{lstlisting}
\end{minipage}\\


\chapter{Generovanie náhodných dát}\label{rng}
Na produkciu náhodných dát má používateľ k dispozícii hneď niekoľko možností. V~rámci tejto práce si rozhrania rozdelíme do dvoch kategórií. 
\begin{itemize}
	\item Hardvérové \acrshort{api} -- závisí od technického vybavenia počítača.
	\item Softvérové \acrshort{api} -- implementáciu služby \acrshort{rng} zabezpečuje  \acrshort{os} alebo knižnice zvoleného jazyka. 
\end{itemize}
V~tejto kapitole uvedené rozdelenie viac charakterizujeme pomocou nasledujúcich podkapitol. 

\section{Hardvérové rozhrania}
Súčasťou moderných procesorov sú~aj~implementácie generátorov skutočne náhodných čísel. Ich~použitie je realizované pomocou procesorových inštrukcií \textbf{\textit{RDRAND a RDSEED}}. 
Práca s~inštrukciami si~vyžaduje znalosti nízko-úrovňových programovacích jazykov, akým je napríklad \textit{Asembler}\footnote{\url{https://en.wikipedia.org/wiki/Assembly\_language}}. Tie nie sú v~dnešnej dobe veľmi populárne. Aj~dôsledkom toho výrobcovia procesorov sprístupňujú programátorom tzv. \textbf{programovateľné rozhrania -- API}. Štandardne sú~napísané pomocou vysoko-úrovňových jazykov\footnote{Jazyk C, Java, C Sharp a iné}. Ich transformáciu do strojového kódu zabezpečuje prekladač.
 
V~tejto súvislosti spomenieme dvoch výrobcov procesorových čipov s~najväčším zastúpením na~trhu -- \textbf{AMD a Intel}. Obe firmy sprístupnili používateľom svoje API v~programovacom jazyku C. Najpodstatnejším rozdielom pri~používaní je~vzájomná kompatibilita. Intel rozhranie poskytuje podporu iba pre~vlastné procesory, zatiaľ čo spoločnosť AMD uverejnila sadu, ktorá má~podporu aj~iných výrobcov procesorových čipov. Podmienkou úspešného generovania však ostáva potrebná implementácia inštrukcií RDRAND a RDSEED. Z~tohto dôvodu sme pri generovaní náhodných dát, pomocou vyššie spomenutých príkazov, použili práve riešenie firmy AMD. 

V súvislosti s inštrukčnými sadami, implementovanými na dnešných mikroprocesoroch, dávame čitateľovi do popredia dokument \cite{instruction}. Jeho obsahom sú všetky sady používané na rôznych typoch procesorov. Dokument je pravidelne aktualizovaný a udržiavaný.      
\subsection{RDRAND a RDSEED}
Inštrukcie vytvorila spoločnosť Intel. Ich vznik sa datuje do roku \textbf{2012}. Samotní autori (\cite{inteldrng}), odôvodnili čipovú implementáciu \acrshort{trng} ako nutný bezpečnostný prvok, ktorý dokáže v~akejkoľvek situácii dodať skutočne náhodné dáta. Samozrejme nezávislé od deterministických procesov bežiaceho softvéru. 

Inštrukcia RDSEED je implementáciou \acrshort{ndrng}. Na druhej strane RDRAND realizuje  \acrshort{csprng}, ktorého zdrojom entropie je výstup RDSEED inštrukcie. Obidva uvedené typy  \acrshort{rng} boli opísané v kapitole \ref{1} tejto práce.  Proces generovania náhodných dát pomocou týchto príkazov je znázornený na~obrázku \ref{o:rdimplementacia}\footnote{Prebraté z: \cite[kap. 3.1]{inteldrng}}.
\begin{figure}[!ht]
	\centering
	\includegraphics[width=.8\textwidth]{figures/dizajnrdinstrukcii}
	\caption{Implementácia procesorových inštrukcií RDRAND a RDSEED\label{o:rdimplementacia}}
\end{figure}
Podrobný opis aplikovaných metód v generátore je dostupný v dokumentácii \cite{intelcycle}.  

Podporu týchto inštrukcií doplnila spoločnosť AMD v roku 2015. Základom bola implementácia Intelu. Viac podrobností o riešení sa nachádza v online dokumente \cite{amdapi}.
     
\subsubsection{AMD Secure RNG API \cite[str. 1-7]{amdapi}}
Voľné dostupné rozhranie\footnote{\url{https://developer.amd.com/amd-aocl/rng-library/}} v~programovacom jazyku C. Aktuálna verzia -- 3.0.6, obsahuje celkovo 14 funkcií. Z~toho dve na kontrolu implementácie inštrukcií a~12 na produkciu náhodných dát. Programátor má možnosť vygenerovať jedno 16/32/64-bitové číslo alebo ich pole. Obdobne je k~dispozícii možnosť zvoliť si požadovanú veľkosť výstupu v~bajtoch. Pri~našom testovaní sme implementovali práve túto možnosť.  Zdrojový kód, \ref{amd},  uvádza deklarácie spomenutých implementovaných funkcií. Pomenovania sú jednoznačné. Argument N označuje počet opakovaní a~\textit{retry\_count} udáva počet pokusov v~prípade zlyhania.

Obsahom balíka je aj zdrojový kód \textbf{secrng\_test.c}. Ten realizuje príklad použitia každého AMD rozhrania.    

\noindent
\begin{minipage}{\linewidth} 	
	%\section{Výpis kódu jazyka C}
	\begin{lstlisting}[frame=single,
		numbers=left,
		caption={Funkcie v AMD Secure RNG rozhraní}\label{amd},
		basicstyle=\ttfamily\small, keywordstyle=\color{black}\bfseries,]	
int is_RDRAND_supported(); 
int get_rdrand16u(uint16_t* rng_val, unsigned int retry_count);
int get_rdrand32u(uint32_t* rng_val, unsigned int retry_count);
int get_rdrand64u(uint64_t* rng_val, unsigned int retry_count);
int get_rdrand32u_arr(uint32_t* rng_val, 
											unsigned int N,
											unsigned int retry_count);
int get_rdrand64u_arr(uint64_t* rng_arr,
											unsigned int N,
											unsigned int retry_count);
int get_rdrand_bytes_arr(unsigned char *rng_arr,
												 unsigned int N,
												 unsigned int retry_count);
int is_RDRAND_supported();
int get_rdseed16u(uint16_t* rng_val, unsigned int retry_count);
int get_rdseed32u(uint32_t* rng_val, unsigned int retry_count);
int get_rdseed64u(uint64_t* rng_val, unsigned int retry_count);
int get_rdseed32u_arr(uint32_t* rng_arr,
											unsigned int N, 
											unsigned int retry_count);
int get_rdseed64u_arr(uint64_t* rng_arr, 
											unsigned int N,
											unsigned int retry_count);
int get_rdseed_bytes_arr(unsigned char *rng_arr, 
												 unsigned int N, 
												 unsigned int retry_count);
	\end{lstlisting}
\end{minipage}\\

\subsubsection{Výsledky experimentálnych meraní}
Dosiahnuté namerané výsledky sú reprezentované formou tabuliek:
\begin{itemize}
	\item \ref{rdrand} -- RDRAND a 
	\item \ref{rdseed} -- RDSEED.
\end{itemize}

\begin{table}[!ht]
	\centering
	\resizebox{\textwidth}{!}{
		\begin{tabular}{c|c|c|c|r|r|r|c|c} 
	\multirow{2}{*}{\bfseries Počítač}&\multicolumn{8}{c}{ \bfseries Špecifikácie meraní}  
	\\ 
& \bfseries $NI$   
& \bfseries $BS$  
& \bfseries $V_D$
& \multicolumn{1}{c|}{ANC}
& \multicolumn{1}{c|}{ \bfseries $T_A$ [s] } 
& \multicolumn{1}{c|}{\bfseries $T_B$[s]}
& \multicolumn{1}{c|}{\bfseries $\approx$ $P_A$ [MB/s]} 
& \multicolumn{1}{c}{\bfseries $\approx$ $P_B$ [MB/s]}
\\\hline\hline
	\multirow{4}{*}{\bfseries A}
	&  1 024   
&  16 kB   
&  16 MB
&  5 628 973
&  1,991 472  
&  1,953 684
&   8,034 
&   8,190
\\
&  1 024   
&  16 MB   
&  16 GB
&  5 676 879 262
& 2 008,291 504 
&  2 015,468 384
&   8,158
&   8,129
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  11 354 590 480
&  4 016,876 709
&   4 050,146 973
&   8,158 
&   8,091
\\			
&  8   
&  ULONG\_MAX   
&  32 GB
&  1 453 162 191 677
&  4 016,253 662  
&  4 051,736 572
&   8,159
&  8,087  
\\\hline
\multirow{4}{*}{\bfseries B}
&  1 024   
&  16 kB   
&  16 MB
&  6 241 786
&  3,551 908
&  3,639 144
&  4,505 
&  4,397
\\
&  1 024   
&  16 MB   
&  16 GB
&  6 440 954 785
& 3 664,190 186  
& 3 685,320 801
&   4,471 
&   4,445
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  12 897 904 573
&  7 337,478 516
&  7 486,955 566
&   4,466 
&   4,377
\\			
&  8  
&  ULONG\_MAX   
&  32 GB
&  1 650 387 205 662 
&  7 335,057 129  
&  7 598,942 383
&   4,467
&  4,312 
\\\hline
\multirow{4}{*}{\bfseries C}
&  1 024   
&  16 kB   
&  16 MB
&  4 805 709
&  2,330 819  
&  2,351 972
&   6,865 
&   8,803
\\
&  1 024   
&  16 MB   
&  16 GB
&  4 810 432 963
& 2 332,328 369
&  2 338,702 881
&   7,025 
&   7,006
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  9 617 320 340
&  4 662,936 523 
&  4 707,775 879
&   7,029 
&   6,960
\\			
&  8   
&  ULONG\_MAX   
&  32 GB
&  1 232 428 756 993
&  4 668,283 203 
&  4 790,067 383
&  7,019
&  6,841  
\\
\end{tabular}
}
	\caption{Výsledky meraní funkcie get\_rand\_bytes\_arr}\label{rdrand}
\end{table}

\begin{table}[!ht]
	\centering
	\resizebox{\textwidth}{!}{
		\begin{tabular}{c|c|c|c|r|r|r|c|c} 
			\multirow{2}{*}{\bfseries Počítač }&\multicolumn{8}{c}{ \bfseries Špecifikácie meraní }  
	\\ 
& \bfseries $NI$   
& \bfseries $BS$  
& \bfseries $V_D$
& \multicolumn{1}{c|}{ANC}
& \multicolumn{1}{c|}{ \bfseries $T_A$ [s] } 
& \multicolumn{1}{c|}{\bfseries $T_B$[s]}
& \multicolumn{1}{c|}{\bfseries $\approx$ $P_A$ [MB/s]} 
& \multicolumn{1}{c}{\bfseries $\approx$ $P_B$ [MB/s]}
\\\hline\hline
			\multirow{4}{*}{\bfseries A}
	&  1 024   
&  16 kB   
&  16 MB
&  24 876 680
&  8,800 674  
&  8,673 107
&   1,818 
&   1,845
\\
&  1 024   
&  16 MB   
&  16 GB
&  25 529 272 494
&  9 031,408 203  
&  8 902,758 789
&   1,814 
&   1,840
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  50 962 566 174
&  17 528,861 328  
&  17 621,734 375
&  1,869  
&   1,860
\\			
&  8   
&  ULONG\_MAX   
&  32 GB
&  6 374 627 781 381
&  17 618,212 891  
&  18 180,208 984
&   1,860
&  1,802 
\\\hline
\multirow{4}{*}{\bfseries B}
&  1 024   
&  16 kB   
&  16 MB
&  6 390 445
& 3,636 515 
&  4,014 131
&   4,400 
&   3,990
\\
&  1 024   
&  16 MB   
&  16 GB
&  6 447 545 248
& 3 667,939 209 
&  3 675,636 963
&   4,467 
&   4,457
\\ 
&  1024   
&  32 MB   
&  32 GB
& 13 112 239 637
&  7 459,411 621 
&  7 479,892 578
&   4,393 
&   4,381
\\			
&  8   
&  ULONG\_MAX   
&  32 GB
&  1 688 133 062 298
&  7 502,824 219 
&  7 615,551 758
&   4,367
&  4,303  
\\\hline
\multirow{4}{*}{\bfseries C}
&  1 024   
&  16 kB   
&  16 MB
&  4 811 400
&  2,333 592  
& 2,367 678
&  6,856 
&   6,758
\\
&  1 024   
&  16 MB   
&  16 GB
&  4 819 373 956
& 2 336,663 330 
& 2 338,929 688
&   7,012 
&   7,005
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  9 615 872 296
&  4 662,234 375  
&  4 706,395 508
&   7,028 
&   6,962
\\			
&  8   
&  ULONG\_MAX   
&  32 GB
& 1 231 308 014 422
&  4 664,037 598
&  4 769,422 363
&   7,026
&  6,870  
\\
		\end{tabular}
	}
	\caption{Výsledky meraní funkcie get\_rdseed\_bytes\_arr}\label{rdseed}
\end{table}

\section{Rozhrania operačného systému Windows}\label{winapi}
Používateľ má v aktuálnom \acrshort{os} Windows\footnote{Windows 10 Home - 64-bit, verzia 20H2, zostava OS -- 19042.964} prístup k trojici funkcií realizujúcich službu \acrshort{rng}\cite[str. 5]{win10rng}. 
\begin{itemize}
	\item \textbf{RtlGenRandom}\cite{rtlgenrandom}
	\item \textbf{CryptGenRandom}\cite{crypt}
	\item \textbf{BCryptGenRandom}\cite{bcrypt}
\end{itemize}
Vyššie uvedené realizujú generovanie náhodných čísel pomocou používateľského rozhrania -- \textbf{ProcessPrng}. V prípade  kernel režimu je produkcia dát vykonaná primárne pomocou \textbf{SystemPrng} API. Tie boli spomenuté v \ref{access}. 
Obsahom tejto podkapitoly je opis týchto funkcií. Ten bol vytvorený na základe webovej dokumentácie spoločnosti Microsoft.
\subsection{RtlGenRandom} \label{rtl} 
Funkcia je deklarovaná v hlavičkovom súbore \textbf{ntsecapi.h}, ale nemá knižnicu, ktorá ju vykonáva. Slúži na generovanie pseudonáhodných čísel. Pomocou makra je definovaná ako \verb|SystemFunction036| a až táto je realizovaná v dynamickej knižnici \textbf{Advapi32.dll}. Pri použití je teda potrebné načítať tento modul. V súčasnosti je tento krok automatizovaný. Generovanie je realizované použitím rozhrania \textbf{ProcessPrng}.
Microsoft však odporúča namiesto používania tejto funkcie použitie \verb|CryptGenRandom|.

\subsubsection{Špecifikácia \cite{rtlgenrandom}}
\verb|RtlGenRandom()| potrebuje dva vstupné parametre.
\begin{enumerate}
	\item \verb|PVOID RandomBuffer| -- adresa premennej na uloženie náhodnosti. 
	\item \verb|ULONG RandomBufferLength| -- veľkosť prvého parametra.
\end{enumerate} 
Funkcia je typu \verb|boolean|. Teda návratové hodnoty sú \verb|TRUE/FALSE| pri úspechu, resp. neúspechu generovania.  
Príkladom  použitia je zdrojový kód \ref{rtlgr}. 

\noindent
\begin{minipage}{\linewidth} 	
	%\section{Výpis kódu jazyka C}
	\begin{lstlisting}[frame=single,
		numbers=left,
		caption={Príklad použitia RtllGenRandom},
		label={rtlgr},
		basicstyle=\ttfamily\small, keywordstyle=\color{black}\bfseries,]	
#include<stdio.h>
#include<windows.h>		// for variable types definition
#include<ntsecapi.h>		// declaration RtlGenRandom()

int main(){
	BYTE *pbData=(BYTE*)malloc(sizeof(BYTE) * 10);
	if(RtlGenRandom(pbData,10) == TRUE){ 
		for (int i = 0; i < 10; i++){
			printf("%u",pbData[i]);
		}
		free(pbData);
		return 0;
	}
	free(pbData);
	return -1;
}	
	\end{lstlisting}
\end{minipage}\\

\subsubsection{Výsledky experimentálnych meraní}
Dosiahnuté výsledky meraní sú znázornené pomocou tabuľky \ref{rtlexp}. 

\begin{table}[!ht]
	\centering
	\resizebox{\textwidth}{!}{
		\begin{tabular}{c|c|c|c|r|r|r|c|c} 
	\multirow{2}{*}{\bfseries Počítač}&\multicolumn{8}{c}{ \bfseries Špecifikácie meraní}  
	\\ 
	& \bfseries $NI$   
	& \bfseries $BS$  
	& \bfseries $V_D$
	& \multicolumn{1}{c|}{ANC}
	& \multicolumn{1}{c|}{ \bfseries $T_A$ [s] } 
	& \multicolumn{1}{c|}{\bfseries $T_B$[s]}
	& \multicolumn{1}{c|}{\bfseries $\approx$ $P_A$ [MB/s]} 
	& \multicolumn{1}{c}{\bfseries $\approx$ $P_B$ [MB/s]}
	\\\hline\hline
	\multirow{4}{*}{\bfseries A}
	&  1 024   
	&  16 kB   
	&  16 MB
	&  15 074
	&  0,005 451 
	&  0,020 702
	&  2 935,241 
	&  772,872
	\\
	&  1 024   
	&  16 MB   
	&  16 GB
	&  16 907 537
	&  5,982 000  
	&  166,227 746
	&   2 738,883 
	&   98,564
	\\ 
	&  1 024   
	&  32 MB   
	&  32 GB
	&  33 698 517
	&  11,922 174  
	&  524,159 006
	&  2 758,492
	&  62,515
	\\			
	&  8   
	&  ULONG\_MAX   
	&  32 GB
	&  4 489 111 941
	&  12,407 025  
	&  500,792 203
	&  2 641,084
	&  65,432 
	\\\hline
	\multirow{4}{*}{\bfseries B}
	&  1 024   
&  16 kB   
&  16 MB
&  10 580
&  0.006 771  
&  0.021 564
&   2 363,019 
&   741,977
\\
&  1 024   
&  16 MB   
&  16 GB
&  14 072 032
&  8,006 607 
&  136,472 897
&  2 046,310
&   120,053
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  29 400 765
&  16,726 991  
&  984,013 108 
&   1 958,990 
&   33,300
\\			
&  8   
&  ULONG\_MAX   
&  32 GB
&  3 940 128 574
&  17,511 696
&  275,192 794
&  1 871,207
&  119,073  
\\\hline
	\multirow{4}{*}{\bfseries C}
	&  1 024   
&  16 kB   
&  16 MB
&  14 630
& 0,007 994  
& 0,024 424
&   2 001,501
&   655,093
\\
&  1 024   
&  16 MB   
&  16 GB
& 11 823 989
& 5,733 827  
&  217,114 585
&   2 857,428
&   75,462
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  23 913 126
&  11,595 265  
&  513,567 815
&   2 825,981
&   63,805
\\			
&  8   
&  ULONG\_MAX   
&  32 GB
&  3 347 779 853
&  12,680 974  
&  561,609 795
&   2 584,029
&  58,347  
\\
\end{tabular}
}
	\caption{Výsledky meraní funkcie RtlGenRandom}\label{rtlexp}
\end{table}

			
\subsection{CryptGenRandom}
Funkcia na generovanie kryptograficky bezpečných náhodných dát. Vznikla pri prvom riešení kryptografického rozhrania -- CAPI. \textbf{Zastaraná}, ale zatiaľ podporovaná aj v súčasnom CNG. Microsoft však \textbf{neodporúča} jej používanie z dôvodu možného odstránenia v~budúcnosti. Jej deklarácia je obsahom hlavičkového súboru \textbf{wincrypt.h}. Realizuje ju dynamická knižnica \textbf{Advapi32.dll}. Následne je použitý modul \textbf{brcyptprimitives.dll}.
\subsubsection{Špecifikácia \cite{crypt}}
Pri inicializácii je potrebná trojica parametrov:
\begin{enumerate}
	\item \verb|HCRYPTPROV hProv|\footnote{Nutná inicializácia tejto premennej} -- popis \acrshort{csp}\footnote{Popísané v \ref{cryptoapi}}, vytvorený funkciou \verb|CryptAcquireContext|,
	\item \verb|DWORD dwLen| -- veľkosť výstupu -- maximum \verb|ULONG_MAX|,
	\item \verb|BYTE *pbBuffer| -- adresa úložiska, veľkosť musí byť najmenej \verb|dwLen|. 
\end{enumerate}
CryptGenRandom je typu \verb|BOOL|. Návratová hodnota je \verb|TRUE|, resp. \verb|FALSE|. V~prípade zlyhania je dôvod zapísaný do \acrshort{csp} premennej.

\noindent
\begin{minipage}{\linewidth} 	
	%\section{Výpis kódu jazyka C}
	\begin{lstlisting}[frame=single,
		numbers=left,
		caption={Ukážka použitia funkcie CryptGenRandom},label={crypt},
		basicstyle=\ttfamily\small, keywordstyle=\color{black}\bfseries,]	
#include<stdio.h>
#include<windows.h>

int main(){
	HCRYPTPROV   hCryptProv;
	BYTE   *pbData=(BYTE*)malloc(sizeof(BYTE)* 10);
	CryptAcquireContext(&hCryptProv,NULL,
		"Microsoft Base Cryptographic Provider v1.0",
											PROV_RSA_FULL,
											CRYPT_VERIFYCONTEXT);
	if(CryptGenRandom(hCryptProv,10,pbData)!=0) 
	{
		printf("Random sequence generated. \n");
	}
	else
	{   
		printf("Error during CryptGenRandom.\n");
		free(pbData);
		return -1;
	}
	free(pbData);
	return 0;
}	
	\end{lstlisting}
\end{minipage}\\

\subsubsection{Výsledky experimentálnych meraní}
Výsledky experimentov funkcie CryptGenRandom znázorňuje tabuľka \ref{cryptexp}.
\begin{table}[h!]
	\centering
	\resizebox{\textwidth}{!}{
		\begin{tabular}{c|c|c|c|r|r|r|c|c} 
	\multirow{2}{*}{\bfseries Počítač}&\multicolumn{8}{c}{ \bfseries Špecifikácie meraní}  
	\\ 
& \bfseries $NI$   
& \bfseries $BS$  
& \bfseries $V_D$
& \multicolumn{1}{c|}{ANC}
& \multicolumn{1}{c|}{ \bfseries $T_A$ [s] } 
& \multicolumn{1}{c|}{\bfseries $T_B$[s]}
& \multicolumn{1}{c|}{\bfseries $\approx$ $P_A$ [MB/s]} 
& \multicolumn{1}{c}{\bfseries $\approx$ $P_B$ [MB/s]}
\\\hline\hline
	\multirow{4}{*}{\bfseries A}
&  1 024   
&  16 kB   
&  16 MB
&  14 242
&  0,006 430  
&  0,022 011
&   2 488,336 
&   726,909
\\
&  1 024   
&  16 MB   
&  16 GB
&  16 991 496
&  6,013 020  
&  143,722 924
&   2 724,754 
&   113,997
\\ 
&  1 024   
&  32 MB   
&  32 GB
& 33795736
&  11,957515  
&  480,253462
&   2 740,369 
&   68,231
\\			
&  8   
&  ULONG\_MAX   
&  32 GB
&  4 525 421 725
&  12,508601  
&  452,834846
&   2 619,637
&  72,362  
\\\hline
\multirow{4}{*}{\bfseries B}
&  1 024   
&  16 kB   
&  16 MB
&  10 545
&  0,008 252  
&  0,021 986
&   1 938,924 
&   727,736
\\
&  1 024   
&  16 MB   
&  16 GB
&  14 174 624
&  8,066 505
&  120,477 247
&   2 031,115 
&   135,992
\\ 
&  1 024   
&  32 MB   
&  32 GB
& 29 485 483 
& 16,776 389
&  982,773 749
&   1 953,221 
&   33,342
\\			
&  8   
&  ULONG\_MAX   
&  32 GB
&  3 969 183 958
&  17,642 095  
&  283,746 065
&   1 857,376
&  115,484  
\\\hline
\multirow{4}{*}{\bfseries C}
&  1 024   
&  16 kB   
&  16 MB
&  10 884
&  0.007 010  
&  0.024 739
&   2 282,454
&   646,752
\\
&  1 024   
&  16 MB   
&  16 GB
&  11 819 580
& 5,733 101  
&  213,303 019
&   2 857,790
&   76,811
\\ 
&  1 024   
&  32 MB   
&  32 GB
& 23 865 849
&  11,573 146  
&  509,545 807
&   2 831,382 
&   64,308
\\			
&  8   
&  ULONG\_MAX   
&  32 GB
&  5 285 174 011
&  20,022 825 
&  561,612 424
&  1 636,532
&  58,346  
\\
\end{tabular}
}
	\caption{Výsledky meraní funkcie CryptGenRandom }\label{cryptexp}
\end{table}
\subsection{BCryptGenRandom}
Implementácia služby generovania náhodných čísel v~druhej verzii kryptografického rozhrania. Ako jediná z uvedených je navrhnutá na použitie v používateľskom aj kernel režime. \textbf{Deklarácia} je uvedená v hlavičkovom súbore \textbf{bcrypt.h}. Funkcia je následne vykonaná pomocou \textbf{bcrypt.dll}. Knižnicu je potrebné pri kompilácií programu prilinkovať. Tento úkon realizujeme pomocou prepínača \verb| -lbcrypt|.     
\subsubsection{Špecifikácia \cite{bcrypt}}
Na inicializáciu potrebujeme štvoricu parametrov:
\begin{enumerate}
	\item\verb|BCRYPT_ALG_HANDLE hAlgorithm| -- popis algoritmu \acrshort{csp}. Vytvára sa použitím funkcie \verb| BCryptOpenAlgorithmProvider|. Tú však nie je nutné inicializovať. Pri použití makra \verb|NULL}| sa použije predvolený poskytovateľ\footnote{Microsoft Cryptographic Service Provider}, ktorý poskytuje služby generovania náhodných čísel. 
	\item\verb|PUCHAR pbBuffer| -- adresa úložiska dát. Veľkosť musí byť najmenej cbBuffer. 
	\item\verb|ULONG cbBuffer| -- veľkosť vygenerovaných dát -- maximálne \verb|ULONG_MAX|.
	\item\verb|ULONG dwFlags| -- značka na modifikovanie správania funkcie.
\end{enumerate}
Posledný z parametrov môže nadobúdať hodnoty:
\begin{itemize}
	\item nula -- je nutné inicializovať \acrshort{csp},
	\item \verb|BCRYPT_RNG_USE_ENTROPY_IN_BUFFER|\footnote{ Od verzie Windows 8 a vyššie je ignorovaný.} -- obsah dát v pbBuffer sa použije ako dodatočný zdroj entropie.
	\item \verb|BCRYPT_USE_SYSTEM_PREFERRED_RNG|\footnote{Windows Vista nepodporuje túto značku.} -- v prípade, že \acrshort{csp} je rovný NULL, volíme tento parameter. 
\end{itemize}  

BCryptGenRandom je typu \verb|NTSTATUS|. Návratové hodnoty môžu byť \verb|STATUS_SUCCESS|, \verb|STATUS_INVALID_HANDLE| a \verb|STATUS_INVALID_PARA-METER|. 

\noindent
\begin{minipage}{\linewidth} 	
	%\section{Výpis kódu jazyka C}
	\begin{lstlisting}[frame=single,
		numbers=left,
		caption={Ukážka použitia BCryptGenRandom},label=bcrypt,
		basicstyle=\ttfamily\small, keywordstyle=\color{black}\bfseries,]	
#include<stdio.h>
#include<windows.h>
#include<ntstatus.h> 
int main(){
	BYTE   *pbData=(BYTE*)malloc(sizeof(BYTE)* 10);
	if (STATUS_SUCCESS!=BCryptGenRandom(NULL,pbData,10,
										  	BCRYPT_USE_SYSTEM_PREFERRED_RNG))
	printf("BCryptGenRandom error.\n");	
	else    printf("Random sequence generated.\n");
	free(pbData);
	return 0;
}	
	\end{lstlisting}
\end{minipage}\\


\subsubsection{Výsledky experimentálnych meraní} 
Výsledky meraní funkcie sú znázornené pomocou tabuľky \ref{bcryptexp}
\begin{table}[!ht]
	\centering
	\resizebox{\textwidth}{!}{
		\begin{tabular}{c|c|c|c|r|r|r|c|c} 
	\multirow{2}{*}{\bfseries Počítač}&\multicolumn{8}{c}{ \bfseries Špecifikácie meraní}  
	\\ 
& \bfseries $NI$   
& \bfseries $BS$  
& \bfseries $V_D$
& \multicolumn{1}{c|}{ANC}
& \multicolumn{1}{c|}{ \bfseries $T_A$ [s] } 
& \multicolumn{1}{c|}{\bfseries $T_B$[s]}
& \multicolumn{1}{c|}{\bfseries $\approx$ $P_A$ [MB/s]} 
& \multicolumn{1}{c}{\bfseries $\approx$ $P_B$ [MB/s]}
\\\hline\hline
	\multirow{4}{*}{\bfseries A}
&  1 024   
&  16 kB   
&  16 MB
& 15 376
&  0,005 560  
& 0,020 745
&   2 877,698 
&   771,270
\\
&  1 024   
&  16 MB   
&  16 GB
&  16 905 128
& 5,981 131  
&  236,919 392
&   2 739,281 
&   69,154
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  33 805 640
&  11,960 016  
&  506,876 314
&   2 739,796 
&   64,647
\\			
&  8   
&  ULONG\_MAX   
&  32 GB
&  4 538 998 240
&  12,544 902
&  568,900 696
&   2 612,057
&  57,599  
\\\hline
\multirow{4}{*}{\bfseries B}
&  1 024   
&  16 kB   
&  16 MB
&  11 011
&  0,007 250  
&  0,066 015
&   2 206,897
&   242,369
\\
&  1 024   
&  16 MB   
&  16 GB
&  14 093 652 
& 8,018 871  
&  117,026 229
&   2 043,180
&   140,003
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  29 396 766
&  16,724 702 
&  845,170 274
&   1 959,257
&   38,771
\\			
&  8   
&  ULONG\_MAX   
&  32 GB
&   3 951 000 676
&  17,560 018 
&  252,854 179
&   1 866,057
&  129,592  
\\\hline
\multirow{4}{*}{\bfseries C}
&  1024   
&  16 kB   
&  16 MB
&  10 912
&  0,005 963
&  0,025 895
&   2 683,213 
&   617,880
\\
&  1 024   
&  16 MB   
&  16 GB
&  11 825 926
& 5,734 744 
&  102,225 511
&   2 856,971 
&   160,273
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  23 915 195
&  11,596 222  
&  437,033 046
&   2 825,748 
&   74,978
\\			
&  8   
&  ULONG\_MAX   
&  32 GB
&  3 346 909 253
&  12,677 676  
&  591,363 044
&  2 584,701
&  55,411  
\\
\end{tabular}
}
	\caption{Výsledky meraní funkcie BCryptGenRandom }\label{bcryptexp}
\end{table}
\section{Knižničné rozhrania}
Používateľ pracujúci na platforme Windows môže okrem softvérových riešení použiť aj implementácie rôznych knižníc. Uvedenou metódou môžeme vytvoriť aplikáciu, resp. službu, nezávislú od operačného systému. Tzv. \textbf{muti-platformové programy}. V~tejto kapitole demonštrujeme vyššie opísaný postup. Použijeme štandardné knižničné rozhrania jazyka C a celosvetovo známu kryptografickú knižnicu -- OpenSSL.   
\subsection{rand() a srand()}
Rand je zrejme najznámejšou funkciou na generovanie pseudonáhodných výstupov, s ktorou sa používateľ stretne. Vo väčšine prípadov je implementáciou lineárne kongruentného generátora. Jeho inicializačná hodnota sa mení pomocou \verb|srand()|. Pri tejto metóde je teda nutnosťou kooperácia týchto funkcií. Ak by sme neurčili seed generátora, výstup by bol vždy rovnaký\footnote{Rovný srand(1)}.
Výstupom funkcie je hodnota z číselnej množiny prvkov 0 až 32767.  
Použitie rozhrania na kryptografické účely sa \textbf{neodporúča}. Z toho dôvodu nevykonáme testovanie tohto rozhrania. Príkladom použitia je zdrojový kód \ref{srand}.
   
\noindent
\begin{minipage}{\linewidth} 	
   	%\section{Výpis kódu jazyka C}
\begin{lstlisting}[frame=single,
   		numbers=left,
		caption={Príklad použitia rand},
		label=srand,
   		basicstyle=\ttfamily\small, keywordstyle=\color{black}\bfseries,]	
#include <stdio.h>
#include <stdlib.h>

int main () {
	time_t t;	
	/* Intializes random number generator */
	srand((unsigned) time(\&t));
		
	/* Print random numbers from 0 to 32767 */
	printf("%d\n", rand());		
	return(0);
}	
\end{lstlisting}
\end{minipage}\\

Viac informácia čitateľ nájde v \cite{crand}.  
\subsection{rand\_s} 
\verb|Rand_S|\footnote{Kompatibilné iba s OS Windows} je vylepšením rozhrania rand. Výstupom sú pseudonáhodné dáta v~rozmedzí od 0 až \verb|UINT_MAX|\footnote{UINT\_MAX = ULONG\_MAX = 4294967295}. Funkcia používa operačný systém, aby vygenerovala kryptograficky bezpečné náhodné dáta. Nepotrebuje srand funkciu.
 
\subsubsection{Špecifikácia}
Funkcia používa jeden vstupný parameter. Ním je adresa na uloženie náhodnosti. Premenná musí byť typu \verb|unsigned int|. 
\verb|Rand_s| je typu \verb|errno_t|. Návratové hodnoty sú nula pri úspechu alebo chybový kód pri zlyhaní. Príkladom použitia je zdrojový kód \ref{rands}.


\noindent
\begin{minipage}{\linewidth} 	
	%\section{Výpis kódu jazyka C}
	\begin{lstlisting}[frame=single,
		numbers=left,
		caption={Príklad použitia rand\_s},
		label=rands,
		basicstyle=\ttfamily\small, keywordstyle=\color{black}\bfseries,]	
#include <stdio.h>
#define _CRT_RAND_S
#include <stdlib.h>

int main () {
	unsigned int data;	
	//generating 10*32bit value
	for (int i = 0; i < 10 ; i++)
	if(rand_s(&data)==0)
		printf("%u\n",data);
	else printf("Rand_S error\n");
	return 0;
}	
	\end{lstlisting}
\end{minipage}\\


Pred použitím je nutné definovať makro \verb|_CRT_RAND_S| pred linkovaním knižnice \textbf{stdlib.h}. Tým je zabezpečená deklarácia \verb|rand_s|. 

Pri hlbšom skúmaní funkcie sme zistili, že \textbf{používa rozhranie RtlGenRandom}. To je obsahom podkapitoly \ref{rtl}. Pri testovaní by teda generovanie trvalo dlhšie, pretože je nutné vykonať viacero krokov. Kvalita výstupných dát je rovnaká ako pri uvedenom rozhraní. Z týchto dôvodov sme v tejto práci neaplikovali testovacie metódy na rozhranie \verb|rand_s|.  
\subsection{OpenSSL }
OpenSSL je široko použiteľná a modifikovateľná knižnica, určená pre kryptografické aplikácie. Jej obsahom sú kvalitné a udržiavané algoritmy. Obdobne obsahuje aj funkcie, ktorých úlohou je generovanie kryptograficky bezpečných náhodných dát. Podľa dokumentácie \cite{openssl} je ich implementácia skonštruovaná podľa odporúčania \cite{book}, teda knižnica \textbf{používa} na generovanie čísel \textbf{AES256-DRBG v počítadlovom režime}. Ekvivalentná bezpečnosť výstupov je teda na úrovni 256 bitov.  
\subsubsection{Špecifikácia \cite[kap. 5]{ossltechreport}}
V tejto práci budeme pracovať s verziou 1.1.1k\footnote{Aktualizovaná 25.03.2021}.    
Predvolený generátor sa inicializuje pri spustení a automaticky vykonáva reseed-ovanie. Pri tomto procese používa dôveryhodné zdroje daného operačného systému. V~prípade \acrshort{os} Windows nimi sú výstupy funkcie \verb|BCryptGenRandom| a \verb|CryptGenRandom|. Tie sú popísané v podkapitole \ref{winapi}   

Prístup k \acrshort{csprng} sprostredkúva dvojica funkcií:
\begin{itemize}
	\item \verb|int RAND\_bytes(unsigned char * buf, int num)|,
	\item \verb|int RAND\_priv\_bytes(unsigned char * buf, int num)|.
\end{itemize}
 Obidve sú deklarované v \textbf{rand.h} a poskytujú výstup z rovnakého \acrshort{csprng}. Druhá z uvedených funkcií používa unikátnu inštanciu generátora. Odporúča sa ju používať pri produkcii citlivých dát. Napríklad pri procese generovania kľúčov. Ukáž- ku jednoduchého použitia v jazyku C znázorňuje zdrojový kód \ref{openssl}. Viac informácií o metódach RNG rozhraní je možne nájsť v riporte \cite[kap. 5]{ossltechreport} 
 
 \noindent
 \begin{minipage}{\linewidth} 	
 	%\section{Výpis kódu jazyka C}
 	\begin{lstlisting}[frame=single,
 		numbers=left,
 		caption={Príklad použitia funkcií OpenSSL},label=openssl,
 		basicstyle=\ttfamily\small, keywordstyle=\color{black}\bfseries,]	
#include <stdio.h>
#include <openssl/rand.h>

int main(){
	unsigned char * data =(unsigned char*)malloc(
												 sizeof(unsigned char)*10);
	unsigned char * data2 =(unsigned char*)malloc(
												  sizeof(unsigned char)*10);
	
	if(RAND_bytes(data,10))
		for (int i = 0; i < 10; i++)
			printf("%u", data[i]);
	else printf("RAND_bytes error\n");
	printf("\n");
	if (RAND_priv_bytes(data2,10))
		for (int i = 0; i < 10; i++)
			printf("%u", data2[i]); 
	else printf("RAND_priv_bytes error\n");
	
	free(data);
	free(data2);
	return 0;
}	
 	\end{lstlisting}
 \end{minipage}\\
 
\subsubsection{Výsledky experimentálnych meraní}
Aj napriek faktu, že knižnica čerpá zdroj náhodnosti z rozhraní operačného systému Windows, sme sa rozhodli aplikovať naše testovacie metódy na funkcie v OpenSSL. Dôvodom je vysoká miera používania v bežnej prevádzke. Prehľad nameraných hodnôt pri časovom meraní znázorňujú tabuľky č.: 
\begin{itemize}
	\item \ref{ossltable1} -- funkcia \verb|RAND\_bytes|,
	\item \ref{ossltable2} -- funkcia \verb|RAND\_priv\_bytes|.
\end{itemize}    
\begin{table}[!ht]
	\centering
	\resizebox{\textwidth}{!}{
		\begin{tabular}{c|c|c|c|r|r|r|c|c} 
	\multirow{2}{*}{\bfseries Počítač}&\multicolumn{8}{c}{ \bfseries Špecifikácie meraní}  
	\\ 
& \bfseries $NI$   
& \bfseries $BS$  
& \bfseries $V_D$
& \multicolumn{1}{c|}{ANC}
& \multicolumn{1}{c|}{ \bfseries $T_A$ [s] } 
& \multicolumn{1}{c|}{\bfseries $T_B$[s]}
& \multicolumn{1}{c|}{\bfseries $\approx$ $P_A$ [MB/s]} 
& \multicolumn{1}{c}{\bfseries $\approx$ $P_B$ [MB/s]}
\\\hline\hline
	\multirow{4}{*}{\bfseries A}
	&  1 024   
	&  16 kB   
	&  16 MB
	&  12 700
	&  0,008 139 
	&  0,022 769
	&   1 965,843 
	&   702,710
	\\
	&  1024   
	&  16 MB   
	&  16 GB
	&  12 371 900
	& 7,039 314  
	&  114,814 303
	&   2 327,500
	&   142,700
	\\ 
	&  1 024   
	&  32 MB   
	&  32 GB
	&  23 384 922
	&  13,304 316  
	&  806,312 717
	&   2 462,960
	&   40,640
	\\			
	&  16   
	&  INT\_MAX   
	&  32 GB
	&  1 662 721 364
	&  9,190 874  
	&  814,555 646
	&  3 565,276
	&  40,228  
	\\\hline
	\multirow{4}{*}{\bfseries B}
	&  1 024   
&  16 kB   
&  16 MB
&  12 700
&  0,008 139 
&  0,022 769
&  1 965,843 
&   702,710
\\
&  1 024   
&  16 MB   
&  16 GB
&  12 371 900
& 7,039 314  
&  114,814 303
&   2 327,500
&   142,700
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  23 384 922
&  13,304 316  
&  806,312 717
&   2 462,960
&   40,639
\\			
&  16   
&  INT\_MAX   
&  32 GB
&  2 079 574 215
&   18,485 125
&  252,108 430
&  1 772,669
&  129,976  
\\\hline
	\multirow{4}{*}{\bfseries C}
	&  1 024   
&  16 kB   
&  16 MB
&  14 043
&  0,007 516 
&  0,021 354
&   2 128,792 
&   749, 274
\\
&  1 024   
&  16 MB   
&  16 GB
&  10 805 372
& 5,239 904
&  232,817 471
&   3 126,775
&   70,373
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  21 915 623
&  10,626 684  
&  517,460 051
&   3 083,558 
&   63,325
\\			
&  16   
&  INT\_MAX   
&  32 GB
&  1 515 908 023
&  11,484 146 
&  564,056 276
&   2 853,325
&  58,093 
\\
\end{tabular}
}
	\caption{Výsledky meraní funkcie RAND\_bytes }\label{ossltable1}
\end{table}
\begin{table}[!ht]
	\centering
	\resizebox{\textwidth}{!}{
		\begin{tabular}{c|c|c|c|r|r|r|r|r} 
	\multirow{2}{*}{\bfseries Počítač}&\multicolumn{8}{c}{ \bfseries Špecifikácie meraní}  
	\\ 
& \bfseries $NI$   
& \bfseries $BS$  
& \bfseries $V_D$
& \multicolumn{1}{c|}{ANC}
& \multicolumn{1}{c|}{ \bfseries $T_A$ [s] } 
& \multicolumn{1}{c|}{\bfseries $T_B$[s]}
& \multicolumn{1}{c|}{\bfseries $\approx$ $P_A$ [MB/s]} 
& \multicolumn{1}{c}{\bfseries $\approx$ $P_B$ [MB/s]}
\\\hline\hline
	\multirow{4}{*}{\bfseries A}
	&  1 024   
&  16 kB   
&  16 MB
&  16 877
&  0,006 082
&  0,005 921
&   2 630,714 
&   2 702,246
\\
&  1 024   
&  16 MB   
&  16 GB
& 12 359 089
&4,372 758  
&  255,915 867
&   3 746,834 
&   64,021
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  24 664 863
&   8,726 003 
&  650,850 067
&   3 755,213 
&   50,346
\\			
&  16   
&  INT\_MAX   
&  32 GB
&  1 261 401 535
&  6,972 535
&  436,126 318
&  4 699,582
&  75,134  
\\\hline
\multirow{4}{*}{\bfseries B}
&  1 024   
&  16 kB   
&  16 MB
&   12 676
&  0,007 968
&  0,008 675
&   2 008,032 
&   1 844,380
\\
&  1 024   
&  16 MB   
&  16 GB
&  12 450 851
& 7,084 268 
& 116,442 791
&   2 312,730
&   140,704
\\ 
&  1024   
&  32 MB   
&  32 GB
&  23 206 632
&  13,202 893
&  1 006,623 945
&   2 481,880 
&   32,552
\\			
&  16   
&  INT\_MAX   
&  32 GB
&  1 566 820 326
&  13,927 308  
&  279,844 212
&   2 352,788
&  117,094  
\\\hline
\multirow{4}{*}{\bfseries C}
&  1 024   
&  16 kB   
&  16 MB
&  13 622
&  0,007 342  
&  0,007 162
&   2 179,243 
&   2 234,013
\\
&  1 024   
&  16 MB   
&  16 GB
&  10 483 219
& 5,083 700  
&  217,651 658
&   3 222,849 
&   75,276
\\ 
&  1 024   
&  32 MB   
&  32 GB
&  21 078 845
&  10,220 949 
& 514,842 818 
&   3 205,965 
&   63,647
\\			
&  16   
&  INT\_MAX   
&  32 GB
&  2 431 597 459
&  18,421 180
&  613,641 577
&  1 778,822
&  53,399
\\
\end{tabular}
}
	\caption{Výsledky merania funkcie RAND\_priv\_bytes }\label{ossltable2}
\end{table}
