%compile with pdflatex
\documentclass[12pt]{article}
\parindent=.25in

\setlength{\oddsidemargin}{0pt}
\setlength{\textwidth}{440pt}
\setlength{\topmargin}{0in}

\usepackage{lmodern}
\usepackage{xspace}
\usepackage[protrusion=true,expansion=true]{microtype}
\usepackage{amssymb}
\usepackage{amsfonts}
\usepackage{amsmath}
\usepackage{amsthm}
\usepackage{latexsym}
\usepackage[center]{subfigure}
\usepackage{epsfig}
\usepackage{hyperref}
\usepackage{mathtools}
\usepackage{graphicx}

% Inline bibliographies
\usepackage{filecontents}
% Algorithm environment
\usepackage{algorithmicx,algpseudocode,algorithm}
% Diagrams and figures in TikZ
\usepackage{tikz}

\usepackage[spanish]{babel}
\usepackage[utf8]{inputenc}

\usetikzlibrary{arrows}
\newcommand{\marginrk}[1]{\marginpar{\tiny#1}}

\newtheorem{theorem}{Teorema}
\newtheorem{lemma}[theorem]{Lema}
\newtheorem{fact}[theorem]{Hecho}
\newtheorem{definition}[theorem]{Definición}
\newtheorem{corollary}[theorem]{Corolario}
\newtheorem{proposition}[theorem]{Proposición}
%\newtheorem{claim}[theorem]{Claim}
\newtheorem{conjecture}[theorem]{Conjectura}
\newtheorem{observation}[theorem]{Observación}
\newtheorem{assumption}[theorem]{Supuesto}
\newtheorem{example}[theorem]{Ejemplo}
\newtheorem{demonstration}[theorem]{Demostración}

\newcommand{\gen}{\mathsf{Gen}}
\newcommand{\enc}{\mathsf{Enc}}
\newcommand{\dec}{\mathsf{Dec}}
\newcommand{\mac}{\mathsf{Mac}}
\newcommand{\vrfy}{\mathsf{Vrfy}}
\newcommand{\hash}{\mathsf{Hash}}
\newcommand{\Exp}{\mathsf{Exp}}

\newcommand{\la}{\langle}
\newcommand{\ra}{\rangle}
\newcommand{\calA}{\mathcal{A}}
\newcommand{\calB}{\mathcal{B}}
\newcommand{\calC}{\mathcal{C}}
\newcommand{\calD}{\mathcal{D}}
\newcommand{\calE}{\mathcal{E}}
\newcommand{\calF}{\mathcal{F}}
\newcommand{\calG}{\mathcal{G}}
\newcommand{\calH}{\mathcal{H}}
\newcommand{\calI}{\mathcal{I}}
\newcommand{\calJ}{\mathcal{J}}
\newcommand{\calK}{\mathcal{K}}
\newcommand{\calL}{\mathcal{L}}
\newcommand{\calM}{\mathcal{M}}
\newcommand{\calN}{\mathcal{N}}
\newcommand{\calO}{\mathcal{O}}
\newcommand{\calP}{\mathcal{P}}
\newcommand{\calQ}{\mathcal{Q}}
\newcommand{\calR}{\mathcal{R}}
\newcommand{\calS}{\mathcal{S}}
\newcommand{\calT}{\mathcal{T}}
\newcommand{\calU}{\mathcal{U}}
\newcommand{\calV}{\mathcal{V}}
\newcommand{\calW}{\mathcal{W}}
\newcommand{\calX}{\mathcal{X}}
\newcommand{\calY}{\mathcal{Y}}
\newcommand{\calZ}{\mathcal{Z}}

\newcommand{\ZZ}{\mathbb{Z}}
\newcommand{\NN}{\mathbb{N}}
\newcommand{\RR}{\mathbb{R}}
\newcommand{\QQ}{\mathbb{Q}}

\newcommand{\sign}{\mathrm{sign}}
\newcommand{\poly}{\mathrm{poly}}
\newcommand{\size}{\mathrm{size}}
\newcommand{\depth}{\mathrm{depth}} 

\newcommand{\experiment}[4]{
{\begin{figure}[h!]
\begin{center}
\fbox{
\small
\hbox{
\begin{minipage}{.90\columnwidth}
{\bf #1}
\bigskip

#4

\end{minipage}
}
}
%\if\full
\vspace{-3pt}
\caption{\label{#3}#2}%\fi
\end{center}
\end{figure}
%\vspace{-10pt}
} }

%% New stuff
% Shortcuts
\newcommand{\eps}{\ensuremath{\epsilon}\xspace}
\newcommand{\negl}{\ensuremath{\mathsf{negl}}\xspace}
\newcommand{\Adv}{\ensuremath{\mathcal{A}}\xspace} % Adversarial algorithm A
\newcommand{\eqdef}{\stackrel{\rm def}{=}}
\newcommand{\accept}{\textsf{ACEPTO}\xspace}
\newcommand{\fail}{\textsf{FALLA}\xspace}
\newcommand{\reject}{\textsf{RECHAZO}\xspace} 
% Complexity
\newcommand{\littleO}[1]{{o\!\left({#1}\right)}}
\newcommand{\bigO}[1]{{O\!\left({#1}\right)}}
\newcommand{\bigTheta}[1]{{\Theta\!\left({#1}\right)}}
\newcommand{\bigOmega}[1]{{\Omega\!\left({#1}\right)}}
\newcommand{\tildeO}[1]{\tilde{O}\!\left({#1}\right)}
\newcommand{\tildeTheta}[1]{\operatorname{\tilde{\Theta}}\!\left({#1}\right)}

\pagestyle{headings}  % Go for customized headings

\newcommand{\handout}[5]{
   \noindent
   \begin{center}
   \framebox{
    \vbox{
  \parbox[t]{4in} {\bf #1 } \vspace{3mm}  {\hfill \bf #2 }
     \vspace{2mm}
     \hbox to 6.00in { {\Large \hfill #5  \hfill} }
     \vspace{1mm}
     \hbox to 6.00in { {\it #3 \hfill #4} }
    }
   }
   \end{center}
   \vspace*{1mm}
}

% compact lists, and handy shortcuts for items
\usepackage[shortlabels]{enumitem}

\begin{document}

\handout{Criptografía y Seguridad Computacional}{2016-01}
{Profesor: Fernando Krell} {Notas: Diego Peña}{Clase 5: 30/03/2016}

\thispagestyle{plain}

\section{Seguridad en Verificación}

Tenemos el siguiente esquema donde se manda un mensaje con tag $t$ de verificación:
	\[
	\texttt{Alice}\xrightarrow{m,t = \textsf{MAC}_k(m)}\texttt{Bob}
	\]
Bob acepta el mensaje m si $\textsf{Vrfy}_k(m,t) = 1$. A partir de esto podemos obtener una nueva definición para seguridad para códigos de autentcación de mensajes mediante el experimento en figura 1. 

Sea $\Pi=\langle\gen,\mac,\vrfy\rangle$ un código de auntenticación de mensajes
    
    \experiment{\large \underline{$\mathsf{\Exp}^{\texttt{fals}}_{\Pi,\calA}(\lambda)$}:}
    {Experimento de falsificación de códigos de autenticación}
    {fig:exp-ind}
    {
    1. $k\leftarrow \gen(1^\lambda)$\\
    2. $m,t\leftarrow \calA^{\mathsf{MAC_k(\cdot)}}(1^\lambda)$\\
    \textbf{output} 1 si, y sólo si, $\mathsf{Vrfy}(m,t) = 1 \wedge m$ no fue consultado al oráculo $\textsf{MAC}_k(\cdot)$
    }

	\begin{definition}\label{def:mac}
	Decimos que $\Pi$ es seguro (infalsificable bajo ataques adaptivos de texto plano escogido) si para todo adversario de tiempo polinomial $\calA$ existe una funcion negligible $\negl$ tal que
	\[
	\Pr[\mathsf{\Exp}^{\texttt{fals}}_{\Pi,\calA}(\lambda) = 1] \leq \negl(\lambda)
	\]
	\end{definition}
	
\paragraph{Construcción basada en PRF:} Sea $F$ es una función pseudoaleatoria $F:\{0,1\}^\lambda\times\{0,1\}^n \rightarrow \{0,1\}^n$ con $n=\poly{\lambda}$. Podemos construir un código the autenticación de mensajes $\Pi=(\gen,\mac,\vrfy)$ como: 
\begin{itemize}
\item $\gen(1^\lambda)$: output $k\sim U_{\lambda}$ (llave para $F$).
\item $\mac_k(m)$: output $F_k(m)$
\item $\vrfy_k(m,t)$: Output 1 si, y sólo si, $F_k(m) = t$.
\end{itemize}

\begin{theorem}
La construcción anterior es un esquema de autenticación de mensajes que satisface definition \ref{def:mac}.
\end{theorem}

	\begin{proof}
	Sea $\calF$ el conjunto de todas las funciones de $\{0,1\}^n$ a $\{0,1\}^n$, y denotemos $f\sim\calF$ el proceso de elegir una función $f$ uniformemente en $\calF.$  
	Reduciremos el problema de falsificar un tag para un mensaje al problema de distinguir entre la función $F$ y una función elegida uniformemente en $\calF$. Para esto construiremos el siguiente distinguidor para $F$:
	
	\experiment{\large \underline{$\mathsf{D}^{O(\cdot)}$}:}
        {Algoritmo distinguidor $D^{O(\cdot)}$ }
    {fig:dist}
    {
    1. Corremos $\calA^{\mac'}(\cdot)$ en donde $\mac'$ es la simulación del oráculo $\mac$ usado en el experimento $\Exp^{\texttt{fals}}$. Este oráculo funciona de la siguiente manera: Inicialmente $Q=\emptyset$, y pára cada consulta $m$, retorna $O(m)$ y guardamos $m$ en $Q$. El adversario $\calA$ retorna el par $m,t$.\\
    2. Output 1 si $O(m)=t \wedge m \notin Q$.
    }
    
    \paragraph{Análisis.} Si el oráculo corresponde a una función uniformemente aleatoria, entonces $O(m)=t$ es $2^n$ si $m$ no fue consultado al oráculo (ya que el valor de $O(m)$ es uniformemente distribuído en $\{0,1\}^n$. Por lo tanto
	\[
	\underset{f \sim \calF}{\Pr}[D^{f(\cdot)}=1] = \Pr[t=O(m)] = \negl(\lambda)
	\]
	Si, en cambio, el oráculo $O(\cdot)$ corresponde a la función $F$, entonces
	el algoritmo distinguidor $D$ esta simulando perfectamente el experimento $\Exp^{\texttt{fals}}_{\Pi,\calA}(\lambda)$, y por lo tanto:
	
	\[
	\underset{k\sim U_{\lambda}}{\Pr}[D^{F_k(\cdot)}=1] = \Pr[\Exp^{\texttt{fals}}_{\calA, \Pi}=1]
	\]
	
	Deducimos entonces que 
	\[
	|\Pr[D^{f(\cdot)}=1] - \Pr[D^{F_k(\cdot)}=1]| \geqslant | 
	\negl(\lambda) - Pr[\Exp^{fals}_{\calA, \Pi}=1]|
	\]
	
	Podemos concluir que si existiese un adversario $\calA$ que rompe a $\Pi$ con  probabilidad no negligible, entonces $F$ no sería pseudoaleatoria.
	\end{proof}		
	
	\section{MAC de largo variable}
	
	En la sección anterior presentamos un MAC para mensajes de largo fijo. ¿Cómo podemos construir un MAC para mensajes de largo variable? 
	\begin{enumerate}
	\item Dividir mensaje $m$ en bloques de largo fijo $n$ y aplicamos $\Pi_{LF}$ (un MAC de largo fijo) a cada bloque (para cada bloque $m_i$ computamos $t_i=\mac_k(m_i)$ y retornamos $t_1,t_2,...,t_\ell$).
	
	¿Es seguro? No. $\calA$ obtiene tag $t^*$ para un mensaje de un solo bloque $m^*$ (v\'ia el or\'aculo $\mac_k(\cdot)$) y retorna $(m=m^*||m^*, t=t*||t*)$. 
	
	\item Segundo intento: $t_i\leftarrow \mac_k(i||m_i)$. Cada bloque es concatenado con el índice del bloque.
	
	A\'un no es seguro. Adversario $\calA$ puede retornar un mensaje que es el prefijo de uno consultado al oráculo. Consulta por $m*=m_1||m_2$ obteniendo $t^*=t_1,t_2$, y retorna $m_1,t_1$.
	
	\item Para prevenir el ataque anterior, cada bloque tamnbién es contatenado con el largo total del mensaje $\ell$ ($t_i\leftarrow \mac_k(i||\ell||m_i)$).
	
	El adversario aún puede atacar llamando al or\'aculo con dos mensajes distintos del mismo largo, y entregar un mensaje nuevo haciendo una mezcla por bloque de los mensajes anteriores (por ejemplo, usar bloque 1 del primer mensaje, pero el bloque 2 del segundo mensaje).
	
	\item Idea final: Aplicar aleatoriedad. Elegimos $r\sim U_{\lambda}$, y cada bloque se tagea como $t_i \leftarrow \mac_k(r||i||\ell||m_i)$
	
	Por supuesto, se utiliza en el mismo $r$ para todos los bloques de un mensaje, siendo la probabilidad de que el mismo $r$ se repita en 2 consultas al oráculo negligible.
	
	\begin{proof}
	Bosquejo: Sea $E$ el evento que $\Exp^{fals}_{\calA,\Pi} = 1$ para algún adversario $\calA$. Entonces,
	\[
	\Pr[E] = \Pr[E \wedge~r \textit{ repite}] + \Pr[E \wedge~r\textit{r no repite}]
	\]
	
	$\Pr[E \wedge~r\textit{ repite}] \leq \Pr[r\textit{ repite}]$, que sabemos que es es negligible en $\lambda$ si el adversario sólo utiliza el oráculo un número polinomial de veces (ver ataque de los cumpleaños más abajo). 
	Para computar $\Pr[E \wedge~r\textit{r no repite}]$  analizamos los siguientes 2 casos:
	\begin{itemize}
	\item[1] $\exists i$ tal que  $m_i$ que no fue consultado al or\'aculo en el output del adversario.
	\item[2] $\forall m_i$ fue consultado al or\'aculo.
	\end{itemize}	 
	Por definici\'on del experimento, la probabilidad de que ocurra el segundo caso es 0, pues no se permite output 1 si hubo una consulta al or\'aculo usando $m_i$. La primera posibilidad por otra parte es igual a falsificar $\Pi_{LF}$.
	\end{proof}
	
	¿Cu\'al es el problema con esta construcci\'on? El tag es 4 veces mayor al mensaje, siendo problem\'atico para mensajes muy largos.
\end{enumerate}	 

\newpage

	\section{CBC-MAC}
	
	\begin{figure}[h]
	\centering
	\includegraphics[scale=0.7]{CBC-MAC}
	\caption{Diagrama de funcionamiento de CBC-MAC}
	\end{figure}
	
	Este algoritmo es seguro pero para mensajes del mismo largo $l$ (queda como ejercicio la demostración). De lo contrario el adversario puede hacer lo siguiente:
	\begin{enumerate}
	\item Consultar por $m_1 \rightarrow t_1 = F_k(m_1)$
	\item Consultar por $m_2 = t_1 \rightarrow t_2=F_k(F_k(m_1))$
	\end{enumerate}
	
	Cómo $m_2 \oplus F_k(m_1) = F_k(m_1) = 0^n$, el adversario puede retornar un nuevo mensaje $m3  = m_1||0^n$ con un tag válido  $t_3= t_1||t_2$.
	
	Esto se puede arreglar utilizando $F$ con una nueva llave al oputput de CBC-MAC.
		
	\section{Funciones de Hash}
	Las funciones de hash son funciones que encogen el input. Por ejemplo, 
	$H:\{0,1\}^{2n}\rightarrow \{0,1\}^n$. Una función de hash  la podriamos usar, por ejemplo, para computar MAC's de la siguiente manera: Usamos $H$ para reducir el largo del input, y luego usamos una función psuedo aleatoria (o un MAC de largo fijo pequeño). Sin embargo, es claro que si un adversario encuentra una colisión ($m1,m2$ tales que $H(m1)=H(m2)$), entonces el esquema MAC no puede ser seguro ya que el adversario podria usar $m1$ para obtener un tag válido via una llamada al oráculo, y este MAC seria válido para $m2$.
	
	Por lo tanto, para aplicaciones criptográficas queremos evitar colisiones.
	Lamentablemente,  es garantizado que las colisiones ocurran (ya que el espacio de input es mayor al espacio de output. Sin embargo, podemos utilizar el enfoque computacional y requerir que encontrar colisiones es ``difícil'' para cualquier algoritmo de tiempo polinomial.
	
En particular tenemos las siguientes tres defuniciones para funciones de hash (de ás fuerte a más débil)
	Una funci\'on de hash se considera segura si:
	\begin{itemize}
	\item[1] Es resistente a colisiones. Es decir que dado un $s$ aleatorio (conocido para el adversario) la probabilidad de encontrar un par de mensajes $x$ y $x'$ tales que $x \neq x'$ y $H^s(x) = H^s(x')$ en tiempo polinomial es negligible en el largo de los elementos del rango de $H$.
	\item[2] Es resistente a segunda preimagen. Dado un $x$ uniforme en el dominio de $H$ la probabilidad de cualquier algoritmo polinomial de encontrar un $x'$ tal que $x \neq x'$ y $H^k(x) = H^k(x')$ es negligible en el largo de los elementos del rango de $H$.
	\item[3] Es resistente a primera preimagen. Dado un valor $y$ en el rango de $H$,la probabilidad de encontrar $x$ tal que $y = H^s(x)$ es negligible
	\end{itemize}
	
	En la tarea se les pide demostrar que si $H$ es resistente a colisiones, entonces $H$ resistente a segunda preimagen, y que si $H$ resistente a segunda preimagen, entonces $H$ resistente a preimagen.
	
\begin{observation}
La llave $s$ es pública (conocida por el adversario), ¿Por qué se necesita? Ninguna función sin llave puede ser resistente a colisiones. Esto es debido a que está garantizado de que existe, al menos en teoría, un algoritmo que retorna la colisión (imaginen el algoritmo que tiene como codigo $x,x'$ tal que $H(x)=H(x')$, y retorna $x,x'$). Este algoritmo encuentra la colisión con probabilidad 1. Por este motivo introducimos una llave aleatoria, de manera que estos algoritmos ganen con probabilidad negligible. Sin embargo, en la práctica utilizamos funciones sin llaves como SHA1,SHA256,SHA3, etc. A pesar de que en teoría existen algoritmos que encuentren colisiones para estas funciones, estos son realmente difíciles de encontrar.
\end{observation}
	
	
	En la práctica, las funciones de hash tienen como dominio $\{0,1\}^*$, y como output $\{0,1\}^n$ ($n=160,256$ por ejemplo). Sin embargo, para construir tal función de hash, se utiliza una de dominio de largo fijo $m > n$. Dado $h:\{0,1\}^m\rightarrow \{0,1\}^n$ resistente a colisiones, podemos construir $H:\{0,1\}^*\rightarrow \{0,1\}^n$ utilizando la transformada de Merkle-Damg\"ard:
	
	Dividimos el input en bloques de largo $m-n$ cada uno (imaginar $m=2n$), el último bloque se agregan 0's hasta que sea de largo $m-n$. Además se le agrega un bloque adicional que contiene el largo original del input (de manera que $x$, $x||0$, $x||00$, etc. tengan distinto hash).
	 
	\begin{figure}[h]
	\centering
	\includegraphics[scale=0.7]{Merkle}
	\caption{Diagrama de funcionamiento de Merkle-Damg\"ard. El IV suele ser $0^n$}
	\end{figure}
	
	Demostramos ahora que si $h$ es resistente a colisiones, entonces $H$ construida utilizando la transformada de Merkle-Dam\"ard es resistente a colisiones.
	
	Sea $\calA$ un adversario que encuentra una colisión en $H$, es decir, encuentra $x,x'\in\{0,1\}^*$ tales que $H(x)=H(x')$. Sea $\ell,\ell'$ los largos de $x$ y $x'$, $x_1,x_2,...,x_B$ los bloques de $x$, y
	 $x_1',x_2',...,x_B'$ la cantidad de bloques de largo $m-n$ de $x'$ para aplicar la transformada sobre $x$ y $x'$ respectivamente. En la transformada a $x$ se le agrega un ultimo bloque $x_{B+1}$ con valor $\ell$ (lo mismo para $x'$).
	 
	 Sea $z_i$ el output del $i$-ésimo paso en la transformada. Es decir, $z_0 = IV=0^n$, $z_1=h(z_0||m_1)$, ..., $z_i = h(z_{i-1}||m_i)$ y $z_{B+1} = h(z_B|| L) = H(m)$. 
	  Analizaremos 2 casos. 1) Si $L\neq L'$, entonces la colisión para $h$ es $z_B||L$ y ${z'}_{B'}||L'$. 2) Si $L=L'$, entonces $B=B'$. Sea $I_i=z_{i-1}||x_i$,
$I'_i=z'_{i-1}||x'_i$, $I_{B+2}=z_{B+1}$, y $I'_{B+2}=z'_{B+1}$. Sea $N$ el máximo tal que $I_N\neq I'_N$ (sabemos que $x\neq x'$, por lo que $x_i\neq x_i'$ para algun $i$ y entonces $N$ esta bien definido). Dado que $I_{B+2} = I_{B+2}$ (colisión en $H$), $N$ es menor o igual a $B+1$. Como $N$ es máximo, $I_{N+1} = I'_{N+1}$, por lo tanto $I_N,I'_N$ es una colisión.
	 
	
	\subsection*{Aplicaciones de funciones de Hash}
	Sea $H$ una funci\'on resistente a colisiones y un $\Pi=(\gen,\mac\vrfy)$ un esquema de autenticación infalsificable para mensajes de largo fijo $n$, y $H=(\gen, \hash)$ una función resistente a colisiones con input de largo variable. Podemos construir un $\Pi'=(\gen', \mac',\vrfy')$ infalsificable para mensajes de largo no definido:
	
	\begin{itemize}
	\item $\gen'(1^{\lambda})$
	\begin{itemize}
	\item $s \leftarrow \gen_H(1^{\lambda})$
	\item $k \leftarrow \gen_{\Pi}(1^{\lambda})$
	\end{itemize}
	\item $\mac'_{\langle s,k\rangle}(m) = \mac_k(H^s(m))$
	\item $\vrfy'_{\langle s,k\rangle}(m,t)$
	\begin{enumerate}
	\item $y = H^s(m)$
	\item $\texttt{output} \vrfy_k(t,y)$
	\end{enumerate}
	\end{itemize}
	
	Sea $\calA'$ un adversario que intenta quebrar $\Pi'$. Si $\calA'$ gana entonces $H$ no es resistente a colisiones o  $\Pi$ es falsificable.
	Informalmente, tenemos:
	\[
	\Pr[\calA'\textit{ gana}] =  \Pr[\calA'\textit{ gana} \wedge \textit{colisión}] + \Pr[\calA' \textit{ gana} \wedge \textit{!colisión}]
	\]
	Pero
	\[
	\Pr[\calA'\textit{ gana} \wedge \textit{colisión}] \leq \Pr[\textit{colisión}] = \textit{negl}(\lambda)
	\]
	y por otro lado,
	\[
	\Pr[\calA' \textit{ gana} \wedge \textit{!colisión}] = \Pr[\textit{ quiebra }\Pi] = \textit{negl}(\lambda)
	\]
	Ejercicio: Formalizar el argumento anterior.
	
	Otras aplicaciones pueden ser:
	\begin{enumerate}
	\item Huellas de virus: Antiviruses cuentan con hashes de viruses con la que comparan programas que se ejecutan en un equipo.
	\item Encontrar duplicados: Evitar mal uso de memoria manteniendo hashes de archivos y evitando generaci\'on de copias.
	\item Derivaci\'on de llaves: Passwords y huellas digitales almacenarlas como una sola llave uniforme.
	\end{enumerate}
	
	\subsection*{Ataque generico a funciones de hash: El ataque de los cumpleaños}
	
	Supongamos $H(x)$ se distribuye uniformemente en ${0,1}^n$ (es decir, supongamos que $H$ es una función aleatoria de). Entonces podemos analizar la probabilidad de colisión como la probabilidad de que en $q$ valores $Y_1,...,Y_q$ distribuidos uniformemente e independientement en ${0,1}^n$, exista $i,j$ tal que $Y_i=Y_j$. Luego, es posible demostrar que 
	\[
	\Pr[\exists i,j| Y_i = Y_j] = \frac{1}{2} \textit{ si } q = 2^{\frac{n}{2}} 
	\]
	
	Por lo tanto cualquier función de hash puede ser quebrada utilizando $2^{\frac{n}{2}}$ valores de $H(\cdot)$. Podemos concluir que, para tener seguridad $2^{\lambda}$, el output de una función de hash resistente a colisiones debe ser mayor a $2\lambda$.
	
	\subsection*{\'Arboles de Merkle}
	
	Supongamos que tenemos un conjunto de archivos, en una base de datos externa (Dropbox, por ejemplo). Para verificar que un archivo obtenido de una base de datos no se haya modificado, podemos comparar el hash del archivo obtenido con el valor hash almacenado. ¿Qu\'e hacemos en el caso de tener muchos documentos? Es incómodo e ineficiente mantener un hash para cada documento. Una solución es armar un \'arbol de hashes para optimizar el proceso de verificaci\'on:
	\begin{figure}[h]
	\centering
	\includegraphics[scale=0.4]{MerkleTree1}
	\caption{Construcci\'on de \'arbol de Merkle}
	\end{figure}
	
	Formamos un árbol en donde las hojas estan asociadas con cada documento. Cada nodo del árbol contiene el hash de la concatenación de sus nodos hijos. El cliente, solo mantiene la raiz del árbol. Esto 	le permite verificar la autenticidad de cualquier documento requerido al servidor de la siguiente manera. Dado un indice $i$, el servidor provee el documento $i$ junto a los $\log n$ hashes de los nodos hermanos del camino de la hija $i$ hasta la raiz.
	El cliente, luego, puede verificar que el documento es autentico, pues si no lo fuera, el computo de la raiz no concidiria con el almacenado localmente o el servidor fue capaz de encontrar una colisión.
	
	\newpage
	
	Por ejemplo, para calcular un $D_5$ en el siguiente \'arbol se requerir\'ia $D_5$, $H_6$, $H_{7,8}$ y $H_{1,4}$: 
	\begin{figure}[h]
	\centering
	\includegraphics[scale=0.4]{MerkleTree2}
	\caption{Ejemplo \'arbol de Merkle}
	\end{figure}
	Si al final se obtiene un $H_{1..n}$ correspondiente al total del grupo de archivos, entonces el $D$ verificado en cuesti\'on es el documento original. Si no, $D$ no est\'a correcto u ocurri\'o una colisi\'on en medio de la operaci\'on.
	
	Ejericio: Demostrar formalmente que el esquema es seguro.
	
\end{document}
