%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{\sign}{\mathsf{Sign}}
\newcommand{\vrfy}{\mathsf{Vrfy}}
\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{\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{\GG}{\mathbb{G}}
\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}[tbp]
\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}
{Fernando Krell}
{Diego Peña}{Clase 9: 04/05/2016}

\thispagestyle{plain}

\section{Firmas Digitales}

\begin{center}
\begin{tabular}[c]{|c | c|}\hline
Criptograf\'ia Sim\'etrica & Criptograf\'ia Asim\'etrica \\
(llave privada) & (llave p\'ublica) \\
\hline
 & \\
llave: $k$ & llave: $\langle pk,sk\rangle $ \\
 & \\
$\enc_k()$ misma llave que $\dec_k()$ & M\'ultiples $\enc_{pk}()$ para un $\dec_{sk}()$ \\
Relaci\'on 1-1 & Relaci\'on N-1\\
\hline
\end{tabular}
\end{center}

Para la criptograf\'ia sim\'etrica hemos estudiado esquemas de autenticación de mensajes. Estos esquemas están compuestos por la tupla de algoritmos $\gen()$, $\mac_k()$ y $\vrfy_k()$. Dado un mensaje $m$ y un tag $t$, supuestamente generado utilizando $\mac_k(m)$, aceptamos $m$ si, y sólo si, $\vrfy_k(m,t) = 1$. Intuitivamente, aceptamos el mensaje si este fue generado por un remitente válido (es decir, que conoce la llave $k$). ¿Qu\'e paralelo existe para autenticación de mensajes en criptograf\'ia asim\'etrica? Las firmas digitales, donde un usuario firma el mensaje con la llave secreta ($\sign_{sk}()$), y varios usuarios pueden verificar un mensaje en base a la correspondiente llave p\'ublica (utilizando $\vrfy_{pk}()$). Formalmente, un esquema de firmas digitales $\Pi$ esta compuesto por 3 algoritmos:

\begin{itemize}
\item $\gen(1^{\lambda})$: Algoritmo probabilista generador de llaves. Dado como input el parámetro de seguridad $\lambda$, genera llave pública $pk$ y correspondiente llave privada $sk$.
\item $\sign_{sk}(m)$: Algoritmo (posiblemente probabilista) de firmas digitales. Dada la llave privada $sk$ y mensaje $m$, genera la firma $\sigma$.

\item $\vrfy_{pk}(m,\sigma)$: Algoritmo verificador de firmas. Dada la llave {\em pública} $pk$, mensaje $m$ y firma $\sigma$, retorna 1 o 0.

\end{itemize}

Requerimos que para todo par ($pk,sk$) generable por $\gen$, y para todo mensaje $m$, si $\sigma \gets \sign_{sk}(m)$, entonces $\vrfy_{pk}(m,\sigma)=1$. Previo a definir la propiedad de seguridad que queremos, intentaremos construir un esquema de firmas digitales basado en el supuesto RSAy analizaremos informalmente su seguridad.

% Necesitamos algo similar a $\textit{MAC}$ pero que me permita verificar p\'iblicamente. Usamos como base algo que ya hace algo parecido a eso:

\begin{itemize}
\item $\gen(1^\lambda)$: $\langle N,e,d\rangle \leftarrow \textit{GenRSA}(1^\lambda)$. Output $pk=\langle N,e\rangle$, $sk=\langle N,d\rangle$
\item $\sign_{sk}(m)$: Output $\sigma\gets m^d\mod N$.
\item $\vrfy_{pk}(m,\sigma)$: Output 1 si, y sólo si, $\sigma^e = m\mod N$.
\end{itemize}


Es fácil de ver que el esquema es correcto. Pero, ¿es este seguro?. A primera vista, pareciera que sí lo es, pués el supuestro RSA nos dice que encontrar $\sigma=m^d \mod N$ tal que $\sigma^e = m$ es computacionalmente díficil, y por lo tanto, un adversario no debería poder generar una firma válida. Sin embargo, el supuesto RSA especifica que el input $m$ tiene que ser uniformemente aleatorio. En la práctica, el mensaje puede venir de una distribución arbitraria que depende de la aplicación sobre la cual estemos usando nuestro esquema de firmas. A continuación describiremos una definición de seguridad suficientemente fuerte de manera tal los esquemas que cumplan con tal definición pueden ser usados en variadas aplicaciones. En la práctica, la firma a falsificar es sobre un mensaje elegido por el adversario. Por lo tanto, nuestra definición debe capturar este hecho. Además, es bastante factible que el adversario pueda obtener firmas válidas de otros mensajes (de hecho las firmas en general son de carácter público). Pero más aun,  es posible que el adversario tenga cierta influencia sobre que mensajes van a ser firmados. Es bastante difícil intuir que tipo de mensajes el atacante puede influenciar ya que esto depende de la aplicación en cuestión. Para suponer lo menos posible de la aplicación y dar una definición global fuerte, daremos al adversario el poder de elegir no tan solo el mensaje a falsificar su firma, si no también firmas de mensajes a su elección. Es decir, describiremos seguridad frente a ataques de mensajes escogidos (CMA). Requeriremos que el adversario no puede generar una firma válida para un mensahe a su elección, aun teniendo acceso a firmas válidas para mensajes escogidos por el adversario.

Sea $\Pi=(\gen, \sign, \vrfy)$  un esquemas de firmas digitales. Para definir formalmente la descripción anterior de seguridad, se plantea el experimento $\Exp_{\calA,\Pi}^\textit{falsFirma}(\lambda)$ ilustrado en la Figura~\ref{fig:exp-fals}.
El experimento comienza generando el par de llaves $(pk,sk)$ utilizando el algoritmo generador de llaves $\gen$. Para modelar el hecho que el adversario puede obtener firmas válidas para mensajes influenciados por este, el experimento utiliza la llave privada $sk$ para dar al adversario acceso a un oráculo de firmas para ser usado arbitrariamente. El oráculo es implementado de la siguiente manera: El adversario envía un mensaje $m_i$ y el experimento utiliza la llave privada para computar la firma como $\sigma_i\gets \sign_{sk}(m_i)$, retornandole la firma al adversario. El adversario, por supuesto, también tiene a su disposición la llave pública. Decimos que el adversario gana si puede generar una firma válida para un mensaje que no haya sido preguntado al oráculo.

\begin{figure}[ht]
\centering
\includegraphics[scale=0.7]{falsfirma}
\caption{Experimento de falsificaci\'on de firmas}
\label{fig:exp-fals}
\end{figure}

\begin{definition}%[Firmas digitales CMA]
Un esquema de firmas digitales $\Pi = (\gen, \sign,\vrfy)$ es infalsificable frente a ataques de mensajes escogidos (o CMA-seguro) si para todo algoritmo PPT $\calA$, existe una función negligible $\negl$ tal que para todo $\lambda$ suficientemente grande:
\[ 
\Pr[\Exp_{\calA,\Pi}^{\textit{falsFirma}}(\lambda)=1]\leq negl(\lambda)
\]
\end{definition}

Para el esquema RSA visto anteriormente, tenemos los siguientes ataques que quiebran su seguridad CMA.

\begin{itemize}
\item Ataque 0 (sin utilizar el oráculo): Ataque trivial: Output $m=1, \sigma =1$.
\item Ataque 1 (sin utilizar el oráculo): Dado un $m$ cualquiera, puede calcular $m^e$ utilizando la llave pública. Por lo tanto $m$ es una firma v\'alida para el mensaje  $m^e$. Ouput  $m'=m^e, \sigma=m$
\item Ataque 2:
\begin{align} 
\nonumber m_1 \rightarrow& \sigma_1 \textit{ v\'ia or\'aculo} \\
\nonumber m_2 \rightarrow& \sigma_2 \textit{ v\'ia or\'aculo}
\end{align} 
Output $m=m_1\times m_2\mod N, \sigma \sigma_1\times \sigma_2\mod M$
\end{itemize}

Esto es una clara vulnerabilidad. ¿C\'omo podemos solucionarlo? Utilizaremos funciones de hash de forma de prevenir ataques algebraicos como los anteriores.
\[
\sign_{sk}(m):~1.\hat{m} \gets H(m) 2. \text{Output: }\sigma = \hat{m}^d \mod N \textit{   (RSA-FDH)}
\]

El esquema anterior de llama RSA-FDH ({\em full-domain hash}). la función $H$ debe cumplir las siguientes propiedades:
\begin{itemize}
\item Dif\'icil de invertir
\item Resistente a colisiones
\item Mapea $m$ a un elemento impredecible. Es decir, es dif\'icil computar $m,m_1,m_2$ tales que, por ejemplo, 
\[
H(m) = H(m_1)H(m_2)
\]
\end{itemize}

\begin{theorem}
Si $H$ es un or\'aculo aleatorio y el supuesto RSA se cumple entonces RSA-FDH es seguro.
\end{theorem}

\begin{proof}
Sea $\calA$ un adversario para RSA-FDH. Construimos un algoritmo $\calB$ que quiebra RSA (asumamos primero que $\calA$ no hace ninguna llamada al or\'aculo $\sign_{sk}(\cdot)$):
\begin{figure}[ht]
\centering
\includegraphics[scale=0.7]{BAlg}
\caption{Variaci\'on sobre el experimento \texttt{falsFirma}. Algoritmo $\calB$}
\end{figure}

Sea $q$ la cantidad de llamdas que $\calA$ hace al oráculo $H$ para poder falsificar la firma. Como $H$ es oráculo aleatorio, es fácil argumentar de que $q>=1$ y que una de estas llamadas tiene que ser $m$ (output del adversario). Pues de lo contrario, la firma es completamente independiente del mensaje, y por lo tanto $\calA$ sólo puede ganar con probabilidad negligible. 

La idea general es que utilizaremos $y=x^e$ como el valor $H(m)$, de manera tal de que si el adversario arroja una firma válida, esta corresponde a $x$, quebrando el supuesto RSA. El problema que tenemos es que no sabemos cuál de estas $q$ llamadas a $H$ ($m_1,m_2, ...m_q$) corresponde al mensaje $m$. La solución es adivinar $i$ tal que $m_i = m$ con probabilidad $1/q$.

Para cada llamada $j\neq i$ a $H$ $\calB$ retorna un elemento uniformemente aleatorio en $\ZZ_N^*$ ($y_j \xleftarrow{\$} Z_N^* \textit{ para } j\neq i$). Para la $i$-\'esima llamada retornamos $y$. Esto significa que cuando el adversario arroje la falsificaci\'on de la firma ($\calA \rightarrow \sigma,m$), entonces
\[
H(m) = y, \sigma = y^d
\]
Pero $(y^d)^e = y$, por lo tanto $\sigma$ quiebra RSA ($\sigma = x \mod N$). La probabilidad de adivinar $i$ es
\[
\Pr[\textit{adivinar i}] = \frac{1}{q} = \frac{1}{poly(\lambda)}
\]
Luego $\Pr[\textit{quebrar RSA}] = \frac{\Pr[\textit{quebrar }\Pi]}{q}$ (tenemos la reducci\'on pues quebrar uno es tan dif\'icil como quebrar el otro). 

Hemos asumido que $\calA$ no utiliza el oráculo de firmas. 
¿Cómo arreglamos la reducción anterior para el caso de que $\calA$ ocupase tal or\'aculo?

Tenemos que simular llamadas al or\'aculo. Asumimos que $\calA$ llama a $H(m_j)$ antes de llamar a $\sign_k(m_j) \forall j$. Para la $j$-\'esima llamada a $H(m_j)$
\[
\sigma_j \leftarrow Z_N^*, y_i = \sigma_i^e \mod N 
\]
Guardamos la tupla $(m_j,y_j,\sigma_j)$ y damos como output $y_j \forall j\neq i$. Cuando $j=i$, output $y$. 

Ahora tenemos que responder las preguntas al or\'aculo, lo cual es f\'acil pues tenemos todas las consultas guardadas. Para cada llamada a $\sign_{sk}(m_j)$:
\begin{itemize}
\item Si $i \neq j$, output $\sigma_j$ (ya guardado)
\item Si $i = j$ abortamos.
\end{itemize}

Por lo tanto, hemos reducido la seguridad CMA de RSA-FHD a quebrar el supuesto RSA.
\end{proof}

\section*{Firmas de Schnorr}

Ahora veremos un nuevo esquema de firmas digitales basado en el problema del logaritmo discreto. No tan solo este nuevo esquema es interesante por utilizar un supuesto distinto, también la demostración utiliza una técnica bastante particular y poderosa no vista antes en clases: la técnica de rebobinar el adversario.

Recordatorio: $\textit{DLog}(g,g^x)$. Dado la descripción de un grupo $\calG$, un generador del grupo $g$, el orden del grupo $q$, y un elemento aleatorio $y$, es computacionalmente dif\'icil de obtener $x$ tal que $g^x = y$.

Sea $H:\{0,1\}^*\rightarrow \ZZ_q$. El esquema de firmas de Schnorr es el siguiente:

\begin{itemize}
\item $\gen(1^{\lambda})$: 1) $(\GG,g,q)\gets \calG$. 2) $x\stackrel{\$}{\gets}\ZZ_q$. 
3) Output $sk=x, pk=g^x$
\item $\sign_k(m)$:1) $k \xleftarrow{\$} Z_q$. 2) $e = H(m,g^k)$. 3)$s = k + ex$ 4) Output $\sigma = \langle s,e\rangle$.
\item $\vrfy_{pk}(m,\sigma)$: 1) $\sigma = \langle s,e\rangle$ 2) $R=g^s\cdot ({g^x})^{-e}$ 3). Output $H(m, R) \stackrel{?}{=} e$
\end{itemize}

Idea: Computar $g^k$ a partir de $g^x$, $s$ y $e$. Luego comparo $H(m,g^k)$ con $e$.

¿Es seguro? Ocupemos la t\'ecnica de rebobinar al adversario:
\begin{theorem}
Si $H$ es un or\'aculo aleatorio y DLog se cumple con respecto a $\calG$ entonces el esquema de firmas de digitales de Schorr es CMA-seguro.
\end{theorem}

\begin{proof}
Describiremos un algoritmo $\calB(G,g,g^x,q)$ para el logaritmo discreto utilizando un adversario $\calA$ que falsifica firmas en el experimento $\Exp_{\Pi,\calA}^{\textit{falsFirmas}}$.

Idea general: Obtener 2 firmas $\sigma=\langle s,e \rangle $ y  $\sigma'=\langle s',e' \rangle $ tales que $g^{s+xe}=g^{s'+xe'}$, y por lo tanto el logaritmo discreto de $g^x$ es $x=(s-s')\cdot (e'-e)^{-1} \mod q$. Para esto ejecutamos el adversario 2 veces, el punto clave es asegurar que las firmas obtenidas tengan la propiedad deseada. Dejaremos este problema para el final de la demostración.

Reducción: Utilizaremos el valor $g^x$ como llave pública para simular el experimento para el adversario $\calA$. Al ejecutar $\calA$ debemos responder preguntas al oráculo $H$ y al oráculo de firmas {\em sin saber la llave privada $x$}. Sea $q$ una cota superior a la cantidad de llamadas realizadas por el oráculo.

\begin{itemize}

\item $H(x)$: Si $T[x]=\bot$, $T[x]\stackrel{\$}{\gets}\ZZ_q$. Retornar $T[x]$ al adversario.

\item $\sign_{sk}(m_i)$:  Obtenemos $s_i,e_i$ uniformes en $\ZZ_q$, y definimos $T(m_i|| g^{s_i-xe_i})=e_i$ (precomputamos el hash y lo guardamos en la tabla $T$).  De esta manera la firma $s_i, e_i$ es una firma válida para el mensaje $m_i$. Un punto importante a notar es que como $s_i$ y $e_i$ son uniformes e independientes, entonces con alta probabilidad el valor $m_i|| g^{s_i-xe_i})$ no fue consultado al oráculo $H$ anteriormente.

\end{itemize}

El adversario finalmente retorna un mensaje $m\neq m_i\forall i\neq q$, y una firma $\sigma \langle s,e\rangle$ tal que $H(m||g^{s-xe}) = e$ con probabilidad no negligible. Al igual que en el caso de RSA, como $H$ es oráculo aleatorio, se puede deducir que el adversario {\em tiene} que haber preguntado por el valor de $H(m||g^r)$ con $g^r=g^{s-xe}$ al oráculo $H$. 

El paso clave de la reducción es: Ejecutamos el adversario nuevamente de manera de obtener una nueva firma $s',e'$. Pero ¿Cómo aseguramos que $g^{s-xe} = g^{s'-xe'}$?. Esto se puede hacer ``rebobinando'' al adversario. El adversario es sólo un programa que podemos ejecutar paso a paso y guardar su estado en cada momento. Por lo tanto, podemos ejecutar normalmente el adversario la primera vez guardando su estado paso a paso. Cuando el adversario retorna el mensaje $m$ y su firma $\sigma = \langle s,e\rangle$, podemos retroceder el adversario justo hasta el momento en el que consulta al oráculo $H$ con input $H(m||g^r)$ (= $H(m|| g^{s-xe})$), pero en vez de retornar $e$ como la primera vez, retornamos un elemento independiente y uniforme $e'$. Luego seguimos la ejecución hasta que el adversario retorna la nueva firma $\sigma'=(s',e')$. Esta vez, sabemos que $g^{s'-xe'} = g^{r} = g^{s-xe}$, y por lo tanto podemos retornar
$x = (s-s')\cdot (e-e')^{-1} \mod q$ como el logaritmo discreto de $g^x$.

\end{proof}

\section*{DSA: Digital Signature Algorithm}
El esquemas de firmas DSA descrito a continuación es el estandar recomendado por el NIST.
Sea $\GG$ un grupo de orden primo $q$ en donde el problema DLog es difícil, y $g$ un generador para $\GG$.

\begin{itemize}
\item $\gen(1^{\lambda})$ $x\stackrel{\$}{\gets} \ZZ_q$, Output $pk=g^x$, $sk=x$

\item $\sign_{sk}(m)$:
\begin{enumerate}
\item $k \stackrel{\$}{\gets} \ZZ_q,~r=F(g^k)$
\item $s = k^{-1}(H(m)+rx)$
\item Output $\langle s,r\rangle$
\end{enumerate}
\item $\vrfy_{pk}(m,\langle s,r\rangle)$: $r \stackrel{\$}{=} F(g^{H(m)s^{-1}}g^{xs^{-1}r})$
\end{itemize}
Correctitud: 
\begin{align*}
 H(m)s^{-1} + xs^{-1}r &= H(m)\cdot k\cdot (H(m)+rx)^{-1} + rxk(H(m)+rx)^{-1}\\
 &=k(H(m)+rx)^{-1}(H(m)+rx)\\
 &= k
\end{align*}
\begin{theorem}
Si $H$ y $F$ son or\'aculos aleatorios, entonces DSA es CMA-seguro.
\end{theorem}
En la pr\'actica $H$ es SHA-1 y $F(g^k)=g^k \mod q$.
\end{document}