229 lines
No EOL
12 KiB
TeX
229 lines
No EOL
12 KiB
TeX
\documentclass[11pt]{scrartcl}
|
|
|
|
\usepackage[utf8]{inputenc}
|
|
\usepackage[T1]{fontenc}
|
|
\usepackage[ngerman]{babel}
|
|
\usepackage{lmodern}
|
|
\usepackage{graphicx}
|
|
\usepackage{listings}
|
|
\usepackage{xspace}
|
|
\usepackage{amsmath}
|
|
\usepackage{algorithm}
|
|
\usepackage{algpseudocode}
|
|
\usepackage{xifthen}
|
|
\usepackage{xcolor}
|
|
\usepackage[a4paper,lmargin={2cm},rmargin={2cm},tmargin={2.5cm},bmargin = {2.5cm},headheight = {4cm}]{geometry}
|
|
\usepackage{amsmath,amssymb,amstext,amsthm}
|
|
\usepackage[shortlabels]{enumitem}
|
|
\usepackage[headsepline]{scrlayer-scrpage}
|
|
\pagestyle{scrheadings}
|
|
\usepackage{titling}
|
|
\usepackage{etoolbox}
|
|
\usepackage{tikz}
|
|
|
|
\usetikzlibrary{shapes, arrows, calc, automata, arrows.meta, positioning,decorations.pathmorphing,backgrounds,decorations.markings,decorations.pathreplacing, graphs}
|
|
\usetikzlibrary{matrix,shapes,arrows,positioning,chains, calc}
|
|
\usetikzlibrary{arrows.meta,matrix,shapes,arrows,positioning,chains, calc}
|
|
|
|
\tikzset{%
|
|
initial text={},
|
|
state/.style={circle, draw, minimum size=.6cm},
|
|
every initial by arrow/.style={-stealth},
|
|
every loop/.append style={-stealth},
|
|
>=stealth
|
|
}
|
|
|
|
\ohead{\parbox[t]{.5\linewidth}{\raggedleft \theauthor}}
|
|
\ihead{System Security, SoSe 24, Assignment \thesheetnr}
|
|
|
|
% Sheet number
|
|
\newcounter{sheetnr}
|
|
\newcommand{\sheetnr}[1]{\setcounter{sheetnr}{#1}}
|
|
|
|
% Exercise environments
|
|
\newenvironment{exercise}[2][]{\section*{#2\expandafter\ifstrempty\expandafter{#1}{}{\ #1}}}{}
|
|
\newenvironment{subexercises}{\begin{enumerate}[a), font=\bfseries, wide, labelindent=0pt]}{\end{enumerate}}
|
|
\newenvironment{subsubexercises}{\begin{enumerate}[i), font=\bfseries, wide, labelindent=0pt]}{\end{enumerate}}
|
|
|
|
% Makros
|
|
% MACRO for whole diagram
|
|
% #1: total width of diagram
|
|
% #2: total height of diagram
|
|
% #3: nodes, paths, ...
|
|
\newcommand\protocolflow[3]{
|
|
\begin{center}
|
|
\begin{tikzpicture}[x=#1cm,y=#2cm]
|
|
#3
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
}
|
|
% MACRO for path line shortening
|
|
% #1: start coordinate
|
|
% #2: target coordinate
|
|
% #3: text above arrow
|
|
\newcommand{\package}[3]{
|
|
\path[*-{latex[width=5pt, length=5pt]}] (#1) edge node [above] {#3} (#2);
|
|
}
|
|
|
|
% Anpassen --> %
|
|
\author{Benjamin Haschka\\Sascha Tommasone\\Paul Zinselmeyer}
|
|
\sheetnr{4}
|
|
% <-- Anpassen %
|
|
\begin{document}
|
|
\begin{exercise}[Warm Up]{2.1.}
|
|
\protocolflow{1.5}{0.75}{
|
|
\node[] (A) at (0,0) {\textbf{Alice}};
|
|
\node[] (E) at (3,0) {\textbf{Eve}};
|
|
\node[] (S) at (7,0) {\textbf{Server}};
|
|
\node[] (B) at (10,0) {\textbf{Bob}};
|
|
\package{0,-1}{3,-1}{$Alice, Bob$}
|
|
\package{3,-2}{7,-2}{$Alice, \textcolor{red}{Eve}$}
|
|
\package{7,-3}{0,-3}{$\{ K \}_{K_{AT}}, \{ K \}_{\textcolor{red}{K_{ET}}}$}
|
|
\package{0,-4}{3,-4}{$Trent, Alice, \{ K \}_{\textcolor{red}{K_{ET}}}$}
|
|
\package{3,-5}{0,-5}{$\{ Hello\ Alice! \}_K$}
|
|
}
|
|
\textbf{Assumptions}
|
|
\begin{itemize}
|
|
\item[(1)] Eve ist Nutzer des Protokolls, damit ein \textit{Key Encryption Key} (KEK) $K_{ET}$ zwischen ihr und dem Key Distribution Center (KDC) existiert.
|
|
\item[(2)] Eve unterliegt dem Angreifermodell \textit{aktiver MitM}.
|
|
\end{itemize}
|
|
|
|
\noindent
|
|
\textbf{Attack}
|
|
\begin{enumerate}
|
|
\item Eve fängt die erste Nachricht [$Alice, Bob$] von Alice ab, ersetzt $Bob$ durch ihren eigenen Namen und leitet die Nachricht anschließend an den KDC weiter.
|
|
\item Der Server antwortet mit [$\{ K \}_{K_{AT}}, \{ K \}_{K_{ET}}$]. Eve lässt diese Nachricht durch.
|
|
\item Nachdem Alice den Session Key erhalten hat, schickt sie den mit $K_{ET}$ verschlüsselten Session Key $K$ an Bob. Damit Bob weiß, mit wem der Session Key ist und wie dieser verschlüsselt ist, schickt Alice nicht nur das Chiffrat, sondern $Trent, Alice$ ebenfalls mit.
|
|
\item Eve fängt die Nachricht [$Trent, Alice, \{ K \}_{K_{ET}}$] ab. Aus (1) folgt, dass Eve in Besitz von $K_{ET}$ ist und kann daher den Session Key $K$ entpacken. Um das Protokoll zu beenden, und Alice endgültig davon zu überzeugen, dass sie Bob ist, schickt Eve $\{ Hello\ Alice! \}_K$ an Alice zurück.
|
|
\end{enumerate}
|
|
|
|
\noindent
|
|
\textbf{Evaluation}
|
|
\begin{itemize}
|
|
\item Der Angriff ist aufgrund fehlender Authentifikation und Integritätsschutzes der Nachrichten möglich.
|
|
\item Der Angriff könnte verhindert werden, in dem die Antwort des KDC an die beiden Identitäten der Kommunikationspartner gebunden wird. Dadurch würde Alice merken, dass sie einen Session Key für sich und Eve statt sich und Bob erhalten hat und könnte die Verbindung droppen. Die IDs müssten mit einem MAC/Signatur an die Antwort gebunden sein, um Manipulationen der IDs zu verhindern.
|
|
\item Um MitM-Angriffe basierend auf einem Replay-Angriff zu verhindern, sollten die Nachrichten mit Noncen versehen werden, sodass jeder Kommunikationspartner die Liveness des anderen Partners/KDC sicherstellen kann. Auch hier sollten MAC/Signaturverfahren zum Manipulationsschutz genutzt werden.
|
|
\end{itemize}
|
|
\end{exercise}
|
|
|
|
\newpage
|
|
\begin{exercise}[Key Establishment]{2.2.}
|
|
\protocolflow{1.5}{0.75}{
|
|
\node[] (A) at (0,0) {\textbf{Alice}};
|
|
\node[] (E) at (5,0) {\textbf{Eve}};
|
|
\node[] (B) at (8,0) {\textbf{Bob}};
|
|
\node[] (CA) at (-1,-4.5) {\text{check $N_A$}};
|
|
\package{0,-1}{5,-1}{$ID_A, N_A$}
|
|
\textcolor{red}{\package{5,-2}{0,-2}{$ID_A, N_A$}}
|
|
\package{0,-3}{5,-3}{$\{ N_A, K'_{AB} \}_{K_{AB}}$}
|
|
\textcolor{red}{\package{5,-4}{0,-4}{$\{ N_A, K'_{AB} \}_{K_{AB}}$}}
|
|
\package{0,-5}{5,-5}{$\{ N_A \}_{K'_{AB}}$}
|
|
\package{5,-6}{0,-6}{\textcolor{red}{$N'_B$}}
|
|
}
|
|
\textbf{Assumptions}
|
|
\begin{enumerate}[(1)]
|
|
\item Eve unterliegt dem Angreifermodell \textit{aktiver MitM}.
|
|
\end{enumerate}
|
|
|
|
\noindent
|
|
\textbf{Attack}
|
|
\begin{enumerate}
|
|
\item Alice startet das Protokoll mit der Nachricht [$ID_A, N_A$] an Bob, die als Challenge dient. Bevor die Nachricht Bob erreicht, reflektiert Eve diese zurück an Alice.
|
|
\item Alice hat somit ihre eigene Challenge selbst erhalten und beantwortet diese, dem Protokoll konform, mit der Response [$\{ N_A, K'_{AB} \}_{K_{AB}}$]. Erneut, bevor die Nachricht Bob erreicht, reflektiert Eve diese zurück an Alice und beantwortet damit die ihr gestellte Challenge.
|
|
\item Alice erhält die Response von Eve, im Glauben sie wäre von Bob und verifiziert nach Entschlüsselung die Nonce $N_A$. Die Verifikation ist bei diesem Angriff immer erfolgreich, weshalb Alice mit [$\{ N_A \}_{K'_{AB}}$] an Bob antwortet.
|
|
\item Eve fängt diese Nachricht wieder ab und sendet ohne Verifikation der Nonce $N_A$ eine Nonce $N'_B$ an Alice zurück, um das Protokoll zu beenden. Eve kann die Nonce nicht verifizieren, da sie nicht in Besitz des Session Keys $K'_{AB}$ ist.
|
|
\item Alice ist nun in dem Glauben, dass sie mit Bob einen neuen Session Key ausgehandelt hat. Stattdessen hat Bob nichts von der Protokollausführung mitbekommen.
|
|
\end{enumerate}
|
|
|
|
\noindent
|
|
\textbf{Evaluation}
|
|
\begin{itemize}
|
|
\item Das Ergebnis des Angriffes ist, dass sich Eve erfolgreich als Bob gegenüber Alice authentifiziert hat. Jedoch ist Eve nicht in Besitz des Session Keys $K'_{AB}$.
|
|
\item Der Angriff ist möglich, da beide Seiten dasselbe Challenge-Response-Protokoll zur gegenseitigen Authentifizierung verwenden.\footnote[1]{https://en.wikipedia.org/wiki/Reflection\_attack}
|
|
\item Der Angriff könnte verhindert werden, indem die ID des Responders in der Response mitgeschickt wird. Diese ID sollte durch mindestens einen MAC oder eine Signatur an den eigentlichen Response-Wert gebunden werden, um jegliche Manipulation der ID zu unterbinden. Erhält einer der Kommunikationspartner eine Response mit seiner eigenen ID, kann er diese verwerfen und die Protokollsitzung beenden.\footnotemark
|
|
\end{itemize}
|
|
\end{exercise}
|
|
|
|
\newpage
|
|
\begin{exercise}[Authentication without Trusted Party]{2.3.}
|
|
\protocolflow{1.5}{0.75}{
|
|
\node[] (A) at (0,0) {\textbf{Alice}};
|
|
\node[] (E) at (5,0) {\textbf{Eve}};
|
|
\node[] (B) at (10,0) {\textbf{Bob}};
|
|
\node[] (CN) at (0,-7) {\text{check $N_A,Sig_B$}};
|
|
% Bob starts Protocol
|
|
\package{10, -2}{5, -2}{\(N_B\)}
|
|
% Eve sends own Nonce (not necessary, but possible)
|
|
\package{5, -3}{0, -3}{\textcolor{red}{\(N_E\)}}
|
|
% Alice answers
|
|
\package{0, -4}{5, -4}{\(N_A, N_E, ID_B, \text{Sig}_A(N_A, N_E, ID_B)\)}
|
|
% Eve uses Bob as oracle - starts a new connection with Bob to obtain the Signature
|
|
\textcolor{red}{\package{5, -5}{10, -5}{\(N_A\)}}
|
|
% Bob answers with the needed signature
|
|
\package{10, -6}{0, -6}{\(N_B', N_A, ID_A, \text{Sig}_B(N_B', N_A, ID_A)\)}
|
|
}
|
|
\textbf{Assumptions}
|
|
\begin{enumerate}[(1)]
|
|
\item Eve unterliegt dem Angreifermodell \textit{aktiver MitM}.
|
|
\end{enumerate}
|
|
|
|
\noindent
|
|
\textbf{Attack}
|
|
\begin{enumerate}
|
|
\item Bob startet das Protokoll, indem er eine Nonce $N_B$ an Alice schickt. Bevor Alice diese Nachricht erhält, ersetzt Eve diese Nonce mit einer eigenen Nonce $N_E$.
|
|
\item Alice sendet in ihrer Antwort an Bob eine eigene Nonce $N_A$, die manipulierte Nonce $N_E$, die ID von Bob $ID_B$ und eine Signatur über diese Daten mit ihrem eigenen Schlüssel.
|
|
Sie erwartet nun in ihrer Antwort eine neue Nonce von Bob, ihre eigene Nonce und ihre ID mit einer Signatur über diese Daten von Bob.
|
|
\item Eve schickt, getarnt als Alice, Alices Nonce an Bob und baut damit eine neue Verbidnung mit Bob auf.
|
|
\item Bob antwortet dann gemäß des Protokolls mit einer Nonce von ihm $N_B'$, Alices Nonce (die Eve ihm geschickt hat), Alices ID, da er meint, dass die Nachricht von Alice kam, und die Signatur über die Nachricht.
|
|
\item Da diese Daten von Alice erwartet werden, kann Eve diese Nachricht einfach an Alice weiterleiten.
|
|
\item Alice prüft die Signatur, die valide ist, sofern Bob keine falsche Signatur erstellt hat, und meint, dass Eve nun Bob ist.
|
|
\end{enumerate}
|
|
|
|
\noindent
|
|
\textbf{Evaluation}
|
|
\begin{itemize}
|
|
\item Das Ergebnis des Angriffes ist, dass sich Eve erfolgreich als Bob gegenüber Alice authentifiziert hat.
|
|
\item Der Angriff ist möglich, da durch eine parallele Session eine Partei als Orakel genutzt werden kann, um die Nachrichten zu generieren.
|
|
\item Der Angriff könnte verhindert werden, indem die erste Nonce $N_B$ in die Signatur von Bob einfließen müsste.
|
|
\end{itemize}
|
|
\end{exercise}
|
|
|
|
\newpage
|
|
\begin{exercise}[Authentication with Trusted Party]{2.4.}
|
|
\protocolflow{1.5}{0.75}{
|
|
\node[] (A) at (0,0) {\textbf{A}};
|
|
\node[] (E) at (3,0) {\textbf{T}};
|
|
\node[] (S) at (6,0) {\textbf{Eve}};
|
|
\node[] (S) at (9,0) {\textbf{S}};
|
|
\node[] (CN) at (9,-7) {\text{check $N_S$}};
|
|
\package{0, -2}{9, -2}{Alice}
|
|
\package{9, -3}{6, -3}{\(N_S\)}
|
|
\textcolor{red}{\package{6, -4}{9, -4}{\(N_S\)}}
|
|
\package{9, -5}{6, -5}{\(\{Alice, \textcolor{red}{N_S}\}_{K_{ST}}\)}
|
|
\textcolor{red}{\package{6, -6}{9, -6}{\(\{Alice, N_S\}_{K_{ST}}\)}}
|
|
|
|
}
|
|
\textbf{Assumptions}
|
|
\begin{enumerate}[(1)]
|
|
\item Eve unterliegt dem Angreifermodell \textit{aktiver MitM}.
|
|
\end{enumerate}
|
|
|
|
\noindent
|
|
\textbf{Attack}
|
|
\begin{enumerate}
|
|
\item A baut eine Kommunikation mit S auf, indem sie die Nachricht Alice an S schickt.
|
|
\item S antwortet mit einer Nonce. Eve fängt diese ab und sendet sie einfach an S zurück.
|
|
\item S erwartet hier die Nonce verschlüsselt von Alice. Daher sendet S einfach die beiden Nachrichten, mit dem gemeinsamen Schlüssel mit T verschlüsselt, an T.
|
|
\item Eve fängt diese Nachricht ab. Da der Trent sich nicht authentifizieren muss, kann Eve einfach die Nachricht an S zurückschicken.
|
|
\item S entschlüsselt die erhaltene Nachricht und prüft die Nonce, die nun korrekt ist.
|
|
\end{enumerate}
|
|
|
|
\noindent
|
|
\textbf{Evaluation}
|
|
\begin{itemize}
|
|
\item Das Ergebnis des Angriffes ist, dass sich Eve erfolgreich als A gegenüber S authentifiziert hat.
|
|
\item Der Angriff funktioniert in erster Linie, weil T sich nicht authentifizieren muss. Zudem sind die beiden letzten Pakete vom Aufbau identisch und können somit einfach miteinander ersetzt werden. Es handelt sich somit um einen \textit{Type Flaw Attack}.
|
|
\item Der Angriff könnte verhindert werden, wenn T sich authentifizieren müsste. Dann könnte ein $MitM$ Angreifer nicht einfach Pakete an T reflektieren.
|
|
\end{itemize}
|
|
\end{exercise}
|
|
\end{document} |